@zuplo/runtime 5.1942.0 → 5.1945.0

package/types-public.d.ts

@@ -0,0 +1,3384 @@
+import { KeyLike } from "jose";
+import type { OpenAPIV3_1 } from "openapi-types";
+import type { ValidateFunction as ValidateFunction_2 } from "ajv";
+
+/**
+ * Amberflo is a usage metering and billing service. This policy allows you to send metering calls for each API to their meter ingest endpoint.
+ *
+ * @remarks
+ * Amberflo {@link https://www.amberflo.io|amberflo.com} is a usage metering and
+ * billing service. This policy allows you to meter API calls going through Zuplo
+ * and send them to your Amberflo account using your Amberflo API key.
+ *
+ * Add the policy to each route you want to meter. Note you can specify the Meter
+ * API Name and Meter Value (meter increment) at the policy level.
+ *
+ * @title Amberflo Metering / Billing
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare function AmberfloMeteringInboundPolicy(
+  request: ZuploRequest,
+  context: ZuploContext,
+  options: AmberfloMeteringInboundPolicyOptions,
+  policyName: string
+): Promise<ZuploRequest<RequestGeneric>>;
+
+/**
+ * The options for this policy. Many of them can be overridden at the code level in a request using the `AmberfloMeteringPolicy.setRequestProperties` method.
+ */
+export declare interface AmberfloMeteringInboundPolicyOptions {
+  /**
+   * The API key to use when sending metering calls to Amberflo.
+   */
+  apiKey: string;
+  /**
+   * The name of the meter to use when sending metering calls to Amberflo (overridable in code).
+   */
+  meterApiName?: string;
+  /**
+   * The value to use when sending metering calls to Amberflo (overridable in code).
+   */
+  meterValue?: number;
+  /**
+   * The path to the property on `request.user` contains the customer ID. For example `.data.accountNumber` would read the `request.user.data.accountNumber` property.
+   */
+  customerIdPropertyPath?: string;
+  /**
+   * The default customerId for all metering calls - overridable in code and by `customerIdPropertyPath`.
+   */
+  customerId?: string;
+  /**
+   * A dictionary of dimensions to be sent to Amberflo (extensible in code).
+   */
+  dimensions?: {
+    [k: string]: string;
+  };
+  /**
+   * A list of successful status codes and ranges "200-299, 304" that should trigger a metering call to Amberflo.
+   */
+  statusCodes?: string | number[];
+  /**
+   * The URL to send metering events. This is useful for testing purposes.
+   */
+  url?: string;
+}
+
+declare interface AmberfloMeteringIngestPayload {
+  customerId: string;
+  meterApiName: string;
+  meterValue: number;
+  meterTimeInMillis: number;
+  dimensions: Record<string, string>;
+}
+
+export declare class AmberfloMeteringPolicy {
+  static setRequestProperties(
+    context: ZuploContext,
+    properties: AmberfloMeteringProperties
+  ): void;
+}
+
+declare interface AmberfloMeteringProperties
+  extends Omit<AmberfloMeteringIngestPayload, "meterTimeInMillis"> {
+  customerId: string;
+}
+
+/* Excluded from this release type: API_KEY */
+
+/**
+ * Authenticates requests based on API Keys using Zuplo API Management. You
+ * can learn more about the Zuplo API Key Service
+ * [here](https://zuplo.com/docs/articles/api-key-api#buckets)
+ *
+ * @remarks
+ * This policy uses the managed API key storage provided by Zuplo.
+ * `allowUnauthenticatedRequests` defaults to false and rejects any request without
+ * a valid API key (returning a `401 - Unauthorized` response). You can override
+ * (set `"allowUnauthenticatedRequests" : true`) this to support multiple
+ * authentication methods or support both authenticated and anonymous requests.
+ *
+ * @deprecated Please use the new {@link https://zuplo.com/docs/policies/api-key-inbound|API Key Authentication} policy
+ * instead. This policy will continue to work but will be removed in a future
+ * version of Zuplo.
+ * @hidden
+ * @title API Key Authentication
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param unparsedOptions - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const ApiAuthKeyInboundPolicy: typeof ApiKeyInboundPolicy;
+
+/**
+ * @deprecated
+ * The options for this policy.
+ */
+export declare interface ApiAuthKeyInboundPolicyOptions {
+  /**
+   * If 'true' allows the request to continue even if authenticated. When 'false' (the default) any unauthenticated request is automatically rejected with a 401.
+   */
+  allowUnauthenticatedRequests?: boolean;
+}
+
+/**
+ * Authenticates requests based on API Keys using Zuplo API Management. You can learn more about the Zuplo API Key Service [here](https://zuplo.com/docs/articles/api-key-api#buckets)
+ *
+ * @remarks
+ * Authenticate requests with Zuplo's fully managed API Key service. This policy is
+ * the easiest way to secure your API and can be combined with other policies like
+ * Rate limiting, quotas, and more to build a fully featured API to support your
+ * partners, developers, or customers.
+ *
+ * For more information on Zuplo's API Key Management service and options enabling
+ * self-serve API Key management see the following resources:
+ *
+ * - {@link https://zuplo.com/docs/articles/api-key-management|API Key Authentication Overview}
+ * - {@link https://zuplo.com/docs/articles/api-key-api|API Key Management API}
+ *
+ * @title API Key Authentication
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param unparsedOptions - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare function ApiKeyInboundPolicy(
+  request: ZuploRequest,
+  context: ZuploContext,
+  unparsedOptions: ApiKeyInboundPolicyOptions,
+  policyName: string
+): Promise<ZuploRequest<RequestGeneric> | Response>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface ApiKeyInboundPolicyOptions {
+  /**
+   * The name of the header with the key.
+   */
+  authHeader?: string;
+  /**
+   * The scheme used on the header.
+   */
+  authScheme?: string;
+  /**
+   * The name of the API Key service bucket. Defaults to the autogenerated bucket name for your project.
+   */
+  bucketName?: string;
+  /**
+   * If requests should proceed even if the policy does not successfully authenticate the request. Defaults to false and rejects any request without a valid API key (returning a `401 - Unauthorized` response). Set to `true` to support multiple authentication methods or support both authenticated and anonymous requests.
+   */
+  allowUnauthenticatedRequests?: boolean;
+  /**
+   * The time to cache authentication results for a particular key. Higher values will decrease latency. Cached results will be valid until the cache expires even in the event the key is deleted, etc.
+   */
+  cacheTtlSeconds?: number;
+  /**
+   * Zuplo will automatically document your API key header within your OpenAPI specification & Developer Portal. Set this to `true` to disable this behavior.
+   */
+  disableAutomaticallyAddingKeyHeaderToOpenApi?: boolean;
+}
+
+/* Excluded from this release type: ApiKeyValidationResult */
+
+export declare interface AuditLogDataStaxInit {
+  url: string;
+  xCassandraToken: string;
+}
+
+export declare class AuditLogDataStaxProvider
+  implements AuditLogOutputProvider
+{
+  #private;
+  constructor(options: AuditLogDataStaxInit);
+  writeLogBatch: (entries: AuditLogEntry[]) => Promise<void>;
+}
+
+declare interface AuditLogEntry {
+  timestamp: Date;
+  durationMs: number;
+  routePath: string;
+  requestId: string;
+  userSub?: string;
+  request: {
+    url: string;
+    method: HttpMethod;
+    headers?: Record<string, string>;
+    body?: string;
+  };
+  response: {
+    status: number;
+    statusText: string;
+    headers?: Record<string, string>;
+    body?: string;
+  };
+}
+
+export declare interface AuditLogInit {
+  requestFilter?: AuditLogRequestFilter;
+  include?: {
+    request?: {
+      headers?: boolean;
+      body?: boolean;
+    };
+    response?: {
+      headers?: boolean;
+      body?: boolean;
+    };
+  };
+}
+
+declare interface AuditLogOutputProvider {
+  writeLogBatch: (entries: AuditLogEntry[]) => Promise<void>;
+}
+
+export declare class AuditLogPlugin extends SystemRuntimePlugin {
+  #private;
+  constructor(outputProvider: AuditLogOutputProvider, init?: AuditLogInit);
+  initialize(runtimeInit: RuntimeExtensions): Promise<void>;
+}
+
+declare interface AuditLogRequestFilter {
+  (request: ZuploRequest, context: ZuploContext): Promise<boolean>;
+}
+
+/**
+ * Authenticate users using Auth0 issued JWT tokens.
+ *
+ * @remarks
+ * Authenticate requests with JWT tokens issued by Auth0. This is a customized
+ * version of the {@link https://zuplo.com/docs/policies/open-id-jwt-auth-inbound|OpenId JWT Policy} specifically
+ * for Auth0.
+ *
+ * @title Auth0 JWT Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const Auth0JwtInboundPolicy: InboundPolicyHandler<Auth0JwtInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface Auth0JwtInboundPolicyOptions {
+  /**
+   * Allow unauthenticated requests to proceed. This is use useful if you want to use multiple authentication policies or if you want to allow both authenticated and non-authenticated traffic.
+   */
+  allowUnauthenticatedRequests?: boolean;
+  /**
+   * Your Auth0 domain. For example, `my-company.auth0.com`.
+   */
+  auth0Domain: string;
+  /**
+   * The Auth0 audience of your API, for example `https://api.example.com/`.
+   */
+  audience?: string;
+}
+
+declare interface AwsLambdaEventV1 {
+  [key: string]: string | null | undefined | number | boolean | object;
+  version: "1.0";
+  resource: string;
+  path: string;
+  httpMethod: string;
+  headers: Record<string, string>;
+  multiValueHeaders: Record<string, string[]>;
+  queryStringParameters: Record<string, string>;
+  multiValueQueryStringParameters: Record<string, string[]>;
+  requestContext: {
+    accountId: string | null;
+    apiId: string | null;
+    authorizer: {
+      claims: Record<string, string>;
+      scopes: string[];
+    };
+    domainName: string;
+    domainPrefix: string | null;
+    extendedRequestId: string;
+    httpMethod: string;
+    identity: {
+      accessKey: null | string;
+      accountId: null | string;
+      caller: null | string;
+      cognitoAuthenticationProvider: null | string;
+      cognitoAuthenticationType: null | string;
+      cognitoIdentityId: null | string;
+      cognitoIdentityPoolId: null | string;
+      principalOrgId: null | string;
+      sourceIp: string | null;
+      user: null | string;
+      userAgent: string | null;
+      userArn: null | string;
+      clientCert: {
+        clientCertPem: null | string;
+        subjectDN: null | string;
+        issuerDN: null | string;
+        serialNumber: null | string;
+        validity: {
+          notBefore: null | string;
+          notAfter: null | string;
+        };
+      };
+    };
+    path: string;
+    protocol: string;
+    requestId: string;
+    requestTime: string;
+    requestTimeEpoch: number;
+    resourceId: string | null;
+    resourcePath: string;
+    stage: null | string;
+  };
+  pathParameters: Record<string, string>;
+  stageVariables: null | Record<string, string>;
+}
+
+declare interface AwsLambdaEventV2 {
+  [key: string]: string | null | undefined | number | boolean | object;
+  version: "2.0";
+  routeKey: string | null;
+  rawPath: string;
+  rawQueryString: string;
+  cookies: string[];
+  headers: Record<string, string>;
+  queryStringParameters: Record<string, string>;
+  requestContext: {
+    accountId: string | null;
+    apiId: string | null;
+    authentication: {
+      clientCert: {
+        clientCertPem: string | null;
+        subjectDN: string | null;
+        issuerDN: string | null;
+        serialNumber: string | null;
+        validity: {
+          notBefore: string | null;
+          notAfter: string | null;
+        };
+      };
+    };
+    authorizer: {
+      jwt: {
+        claims: Record<string, string>;
+        scopes: string[];
+      };
+    };
+    domainName: string | null;
+    domainPrefix: string | null;
+    http: {
+      method: string;
+      path: string;
+      protocol: string;
+      sourceIp: string | null;
+      userAgent: string | null;
+    };
+    requestId: string;
+    routeKey: string | null;
+    stage: null;
+    time: string;
+    timeEpoch: number;
+  };
+  pathParameters: Record<string, string>;
+  stageVariables: string | null;
+}
+
+/* Excluded from this release type: awsLambdaHandler */
+
+export declare const AwsLambdaHandlerExtensions: {
+  addSendingAwsLambdaEventHook: (hook: OnSendingAwsLambdaEventHook) => void;
+};
+
+declare interface AWSLoggingOptions {
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  logGroupName: string;
+  logStreamName: string;
+}
+
+export declare class AWSLoggingPlugin extends LogPlugin {
+  private options;
+  constructor(options: AWSLoggingOptions);
+  getTransport(): LogTransport;
+}
+
+export declare class BackgroundDispatcher<TPayload> {
+  #private;
+  constructor(
+    dispatcher: DispatchFunction<TPayload>,
+    options: BatchDispatcherOptions
+  );
+  enqueue: (payload: TPayload) => void;
+}
+
+export declare class BackgroundLoader<T = unknown> {
+  #private;
+  constructor(loader: BackgroundLoaderFunction<T>, ttlSeconds: number);
+  get(key: string): Promise<T>;
+}
+
+declare interface BackgroundLoaderFunction<T> {
+  (key: string): Promise<T>;
+}
+
+/* Excluded from this release type: BaseCryptoBeta */
+
+/* Excluded from this release type: BaseKeyValueStore */
+
+/**
+ * An account object.
+ */
+declare interface BasicAuthAccount {
+  /**
+   * The username for the account (this will be the `sub` property on `request.user`.
+   */
+  username: string;
+  /**
+   * The password for the account - note we recommend storing this in environment variables.
+   */
+  password: string;
+  /**
+   * The data payload you want associated with this account (this will be the `data` property on `request.user`).
+   */
+  data?: {
+    [k: string]: unknown;
+  };
+}
+
+/**
+ * Authenticate requests using basic auth (i.e. username and password)
+ *
+ * @remarks
+ * The Basic Authentication policy allows you to authenticate incoming requests
+ * using the Basic authentication standard. You can configure multiple accounts
+ * with different passwords and a different bucket of user 'data'.
+ *
+ * The API will expect a Basic Auth header (you can generate samples
+ * {@link https://www.debugbear.com/basic-auth-header-generator|here}). Requests with
+ * invalid credentials (or no header) will not be authenticated. Authenticated
+ * requests will populate the `user` property of the `ZuploRequest` parameter on
+ * your RequestHandler.
+ *
+ * @title Basic Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const BasicAuthInboundPolicy: InboundPolicyHandler<BasicAuthInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface BasicAuthInboundPolicyOptions {
+  /**
+   * An array of account objects (username, password and data properties).
+   */
+  accounts: BasicAuthAccount[];
+  /**
+   * If 'true' allows the request to continue even if authenticated. When 'false' (the default) any unauthenticated request is automatically rejected with a 401.
+   */
+  allowUnauthenticatedRequests?: boolean;
+}
+
+/* Excluded from this release type: BatchDispatch */
+
+declare interface BatchDispatcherOptions {
+  msDelay: number;
+  name?: string;
+}
+
+/* Excluded from this release type: BuildEnvironment */
+
+declare interface BuildRouteConfiguration {
+  path: string;
+  methods: HttpMethod[];
+  /**
+     /* @deprecated This property is not used and will be removed in future versions
+     */
+  label?: string;
+  /**
+     /* @deprecated This property is not used and will be removed in future versions
+     */
+  key?: string;
+  handler: HandlerDefinition;
+  corsPolicy?: CorsPolicy;
+  /**
+     /* @deprecated This property is deprecated. Use route.raw() instead.
+     */
+  custom?: any;
+  /**
+     /* @deprecated This property is not used and will be removed in future versions
+     */
+  version: string;
+  policies?: {
+    inbound?: string[];
+    outbound?: string[];
+  };
+  /**
+     /* @deprecated This property is deprecated. Use route.raw() instead.
+     */
+  excludeFromOpenApi?: boolean;
+  pathPattern?: string;
+  /* Excluded from this release type: raw */
+}
+
+/**
+ * Internal
+ */
+declare interface CacheOptions {
+  logger?: Logger;
+}
+
+/**
+ * Respond to matched incoming requests with cached content
+ *
+ * @title Caching
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare function CachingInboundPolicy(
+  request: ZuploRequest,
+  context: ZuploContext,
+  options: CachingInboundPolicyOptions,
+  policyName: string
+): Promise<ZuploRequest<RequestGeneric> | Response>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface CachingInboundPolicyOptions {
+  /**
+   * Specifies an id or 'key' for this policy to store cache. This is useful for cache-busting. For example, set this property to an env var and if you change that env var value, you invalidate the cache.
+   */
+  cacheId?: string;
+  /**
+   * By default, the Authorization header is always considered in the caching policy. You can disable by setting this to `true`.
+   */
+  dangerouslyIgnoreAuthorizationHeader?: boolean;
+  /**
+   * The headers to be considered when caching.
+   */
+  headers?: string[];
+  /**
+   * HTTP Methods to be cached. Valid methods are: GET, POST, PUT, PATCH, DELETE, HEAD.
+   */
+  cacheHttpMethods?: ("GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD")[];
+  /**
+   * The timeout of the cache in seconds.
+   */
+  expirationSecondsTtl?: number;
+  /**
+   * Response status codes to be cached.
+   */
+  statusCodes?: number[];
+}
+
+/**
+ * Changes the HTTP method of the incoming request.
+ *
+ * @title Change Method
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const ChangeMethodInboundPolicy: InboundPolicyHandler<ChangeMethodInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface ChangeMethodInboundPolicyOptions {
+  /**
+   * The HTTP Method to be used, e.g. POST, GET, PUT, PATCH, etc.
+   */
+  method: string;
+}
+
+/**
+ * Removes all headers from the incoming request except for those in the exclude list.
+ *
+ * @title Clear Request Headers
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const ClearHeadersInboundPolicy: InboundPolicyHandler<ClearHeadersInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface ClearHeadersInboundPolicyOptions {
+  /**
+   * The headers that should not be removed.
+   */
+  exclude?: string[];
+}
+
+/**
+ * Removes all headers from the response except for those in the exclude list.
+ *
+ * @title Clear Response Headers
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const ClearHeadersOutboundPolicy: OutboundPolicyHandler<ClearHeadersOutboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface ClearHeadersOutboundPolicyOptions {
+  /**
+   * The headers that should not be removed.
+   */
+  exclude?: string[];
+}
+
+/**
+ * Authenticate users using Clerk issued JWT tokens.
+ *
+ * @remarks
+ * Authenticate requests with JWT tokens issued by Clerk. This is a customized
+ * version of the {@link https://zuplo.com/docs/policies/open-id-jwt-auth-inbound|OpenId JWT Policy} specifically
+ * for Clerk.
+ *
+ * @title Clerk JWT Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const ClerkJwtInboundPolicy: InboundPolicyHandler<ClerkJwtInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface ClerkJwtInboundPolicyOptions {
+  /**
+   * Allow unauthenticated requests to proceed. This is use useful if you want to use multiple authentication policies or if you want to allow both authenticated and non-authenticated traffic.
+   */
+  allowUnauthenticatedRequests?: boolean;
+  /**
+   * Your Clerk frontend api url, i.e. `https://sensible-skunk-49.clerk.accounts.dev`. Can be found in the Clerk portal: https://dashboard.clerk.com/last-active?path=api-keys.
+   */
+  frontendApiUrl: string;
+}
+
+/**
+ * Authenticate requests with JWT tokens issued by AWS Cognito.
+ *
+ * @remarks
+ * Authenticate requests with JWT tokens issued by AWS Cognito. This is a
+ * customized version of the {@link https://zuplo.com/docs/policies/open-id-jwt-auth-inbound|OpenId JWT Policy}
+ * specifically for AWS Cognito.
+ *
+ * See {@link https://zuplo.com/docs/articles/oauth-authentication|this document} for more information
+ * about OAuth authorization in Zuplo.
+ *
+ * @title AWS Cognito JWT Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const CognitoJwtInboundPolicy: InboundPolicyHandler<CognitoJwtInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface CognitoJwtInboundPolicyOptions {
+  /**
+   * Allow unauthenticated requests to proceed. This is use useful if you want to use multiple authentication policies or if you want to allow both authenticated and non-authenticated traffic.
+   */
+  allowUnauthenticatedRequests?: boolean;
+  /**
+   * The AWS region where your Cognito instance is deployed.
+   */
+  region: string;
+  /**
+   * The user pool identifier.
+   */
+  userPoolId: string;
+}
+
+/**
+ * The compatibility date on which to run the gateway
+ */
+declare type CompatibilityDate = "2023-03-14" | "2024-01-15";
+
+declare interface CompatibilityFlags {
+  /**
+   * Whether or not outbound policies should run if the response from the
+   * handlers is not `response.ok`
+   *
+   * @compatibilityDate 2024-01-15
+   */
+  runOutboundPoliciesOnHandlerOnAllStatuses: boolean;
+  /**
+   * Whether or not hooks run on system routes
+   *
+   * @compatibilityDate 2024-01-15
+   */
+  doNotRunHooksOnSystemRoutes: boolean;
+  /**
+   * Remove all vendor (cf-, zp-) headers except for the specific
+   * list of allowed headers
+   *
+   * @compatibilityDate 2024-01-15
+   */
+  removeAllVendorHeadersExceptListed: boolean;
+}
+
+/**
+ * Creates a composite, or group policy - composed of other policies. For reuse across routes.
+ *
+ * @remarks
+ * The Composite policy allows you to create groups of other policies, for easy
+ * reuse across multiple routes. Other policies are referenced by their `name`.
+ *
+ * Be careful not to create circular references which can cause your gateway to
+ * fail.
+ *
+ * @title Composite Inbound (Group Policies)
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const CompositeInboundPolicy: InboundPolicyHandler<CompositeInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface CompositeInboundPolicyOptions {
+  /**
+   * The list of policy references (beware circular references).
+   */
+  policies?: string[];
+}
+
+/**
+ * Errors caused by invalid user configuration -i.e. invalid parameters on policies,
+ * handlers that are not functions, etc. This is not for zuplo system configuration errors,
+ * use SystemError for that.
+ * @public
+ */
+export declare class ConfigurationError extends RuntimeError {
+  constructor(message: string, options?: ErrorOptions);
+}
+
+/* Excluded from this release type: ContentTypes */
+
+/**
+ * Utility for storing data across the lifecycle of a request. This class is
+ * useful for storing and retrieving data that is shared between policies.
+ *
+ * @public
+ *
+ * @example
+ * Using static methods
+ * ```
+ * ContextData.set(context, "my-data", { prop1: "hello world" });
+ *
+ * const data = ContextData.get(context, "my-data");
+ * ContextData.set(context, data);
+ * ```
+ *
+ * @example
+ * Reusable class shared across modules
+ *
+ * The shared module allows other modules to access the same storage without
+ * passing the string name or type around.
+ *
+ * ```
+ * export const myData =
+ *    new ContextData<{ prop1: string }>("my-data");
+ * ```
+ *
+ * Then use the class in another module.
+ *
+ * ```
+ * import { myData } from "./my-module";
+ *
+ *
+ * const data = myData.get(context)
+ * myData.set(context, data);
+ *
+ * ```
+ */
+export declare class ContextData<T = any> {
+  #private;
+  constructor(name: string);
+  set(context: ZuploContext, data: T): void;
+  get(context: ZuploContext): T | undefined;
+  static set<T = any>(context: ZuploContext, name: string, data: T): void;
+  static get<T = any>(context: ZuploContext, name: string): T | undefined;
+}
+
+/** The 2-letter continent codes Cloudflare uses */
+declare type ContinentCode = "AF" | "AN" | "AS" | "EU" | "NA" | "OC" | "SA";
+
+export declare type CorsPolicy = string | "anything-goes" | "none";
+
+export declare interface CorsPolicyConfiguration {
+  name: string;
+  allowCredentials?: boolean;
+  maxAge?: number;
+  allowedOrigins: string[] | string;
+  allowedMethods?: HttpMethod[] | string;
+  allowedHeaders?: string[] | string;
+  exposeHeaders?: string[] | string;
+}
+
+/* Excluded from this release type: CryptoBeta */
+
+/**
+ * Authenticate users using the Curity Phantom Token Pattern.
+ *
+ * @remarks
+ * Authenticate requests with Phantom Tokens issued by Curity. The payload of the
+ * Phantom JWT token, if successfully authenticated, with be on the
+ * `request.user.data` object accessible to the runtime.
+ *
+ * @title Curity Phantom Token Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const CurityPhantomTokenInboundPolicy: InboundPolicyHandler<CurityPhantomTokenInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface CurityPhantomTokenInboundPolicyOptions {
+  /**
+   * The client ID of the Curity application.
+   */
+  clientId: string;
+  /**
+   * The client secret of the Curity application.
+   */
+  clientSecret: string;
+  /**
+   * The introspection URL of the Curity application.
+   */
+  introspectionUrl: string;
+  /**
+   * The duration in seconds to cache the introspected response.
+   */
+  cacheDurationSeconds?: number;
+}
+
+/* Excluded from this release type: CustomRateLimitDetails */
+
+declare interface DataDogLoggingOptions {
+  url?: string;
+  apiKey: string;
+}
+
+export declare class DataDogLoggingPlugin extends LogPlugin {
+  private options;
+  constructor(options: DataDogLoggingOptions);
+  /* Excluded from this release type: getTransport */
+}
+
+declare interface DataDogMetricsContext {
+  tags: string[];
+}
+
+declare interface DataDogMetricsOptions {
+  url?: string;
+  apiKey: string;
+  tags?: string[];
+  metrics?: MetricsType;
+  include?: IncludeMetrics;
+}
+
+export declare class DataDogMetricsPlugin extends MetricsPlugin {
+  private options;
+  constructor(options: DataDogMetricsOptions);
+  getTransport(): MetricsTransport;
+  static setContext(context: ZuploContext, data: DataDogMetricsContext): void;
+}
+
+export declare interface DevPortalRuntimeConfig {
+  enabled: boolean;
+  sitePathname: string;
+}
+
+/* Excluded from this release type: DispatchFunction */
+
+declare interface DynaTraceLoggingOptions {
+  url: string;
+  apiToken: string;
+}
+
+export declare class DynaTraceLoggingPlugin extends LogPlugin {
+  private options;
+  constructor(options: DynaTraceLoggingOptions);
+  /* Excluded from this release type: getTransport */
+}
+
+declare interface DynatraceMetricsContext {
+  dimensions: string[];
+}
+
+declare interface DynatraceMetricsOptions {
+  url: string;
+  apiToken: string;
+  dimensions?: string[];
+  metrics?: MetricsType;
+  include?: IncludeMetrics;
+}
+
+export declare class DynatraceMetricsPlugin extends MetricsPlugin {
+  private options;
+  constructor(options: DynatraceMetricsOptions);
+  getTransport(): MetricsTransport;
+  static setContext(context: ZuploContext, data: DynatraceMetricsContext): void;
+}
+
+/* Excluded from this release type: environment */
+
+/* Excluded from this release type: ErrorHandler */
+
+/* Excluded from this release type: ErrorObject */
+
+/**
+ * Authenticate users using Firebase issued JWT tokens.
+ *
+ * @remarks
+ * Authenticate requests with JWT tokens issued by Firebase. The payload of the JWT
+ * token, if successfully authenticated, with be on the `request.user.data` object
+ * accessible to the runtime.
+ *
+ * See {@link https://zuplo.com/docs/articles/oauth-authentication|this document} for more information
+ * about OAuth authorization in Zuplo.
+ *
+ * @title Firebase JWT Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const FirebaseJwtInboundPolicy: InboundPolicyHandler<FirebaseJwtInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface FirebaseJwtInboundPolicyOptions {
+  /**
+   * Allow unauthenticated requests to proceed. This is use useful if you want to use multiple authentication policies or if you want to allow both authenticated and non-authenticated traffic.
+   */
+  allowUnauthenticatedRequests?: boolean;
+  /**
+   * Your Firebase Project ID.
+   */
+  projectId: string;
+}
+
+/**
+ * Converts form data in the incoming request to JSON.
+ *
+ * @title Form Data to JSON
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const FormDataToJsonInboundPolicy: InboundPolicyHandler<FormDataToJsonInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface FormDataToJsonInboundPolicyOptions {
+  /**
+   * Should the policy return an error if the request is not of the type form data.
+   */
+  badRequestIfNotFormData?: boolean;
+  /**
+   * The name of the honeypot field. Used to provide basic spam filtering.
+   */
+  optionalHoneypotName?: string;
+}
+
+/* Excluded from this release type: Gateway */
+
+/**
+ * Block requests based on geo-location parameters: country, region code, and ASN
+ *
+ * @title Geo-location filtering
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const GeoFilterInboundPolicy: InboundPolicyHandler<GeoFilterInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface GeoFilterInboundPolicyOptions {
+  block?: GeoSpec;
+  allow?: GeoSpec;
+  /**
+   * Specifies whether unknown geo-location parameters should be ignored (allowed through).
+   */
+  ignoreUnknown?: boolean;
+}
+
+declare interface GeoSpec {
+  /**
+   * comma separated string of country codes to allow (e.g. "US, CA").
+   */
+  countries?: string;
+  /**
+   * comma separated string of region codes to allow (e.g. "TX, WA").
+   */
+  regionCodes?: string;
+  /**
+   * comma separated string of ASNs to allow (e.g. "395747, 28304").
+   */
+  asns?: string;
+}
+
+export declare function getIdForParameterSchema(
+  path: string,
+  operation: string,
+  type: string,
+  name: string
+): string;
+
+export declare function getIdForRefSchema(
+  oasFileName: string,
+  ref: string
+): string;
+
+export declare function getIdForRequestBodySchema(
+  path: string,
+  operation: string,
+  contentType: string
+): string;
+
+export declare function getRawOperationDataIdentifierName(
+  oasFileName: string,
+  path: string,
+  operation: string
+): string;
+
+declare interface GoogleCloudLoggingOptions {
+  serviceAccountJson: string;
+  logName: string;
+}
+
+export declare class GoogleCloudLoggingPlugin extends LogPlugin {
+  private options;
+  constructor(options: GoogleCloudLoggingOptions);
+  /* Excluded from this release type: getTransport */
+}
+
+/* Excluded from this release type: Handler */
+
+export declare interface HandlerDefinition {
+  module: any;
+  export: string;
+  options?: unknown;
+}
+
+export declare type HttpMethod =
+  | "GET"
+  | "HEAD"
+  | "POST"
+  | "PUT"
+  | "DELETE"
+  | "CONNECT"
+  | "OPTIONS"
+  | "TRACE"
+  | "PATCH";
+
+/* Excluded from this release type: HttpProblems */
+
+declare class HttpProblemsBase {
+  /**
+   * Creates a Response in the standard format from a problem detail
+   * @param details - The details of the problem
+   * @param request - The ZuploRequest object
+   * @param context - The ZuploContext object
+   * @returns A HTTP Response promise
+   */
+  static format: (
+    details: ProblemDetails | ProblemResponseDetails,
+    request: ZuploRequest,
+    context: ZuploContext
+  ) => Promise<Response>;
+  /**
+   * Creates a problem from the status code
+   */
+  static getProblemFromStatus(
+    status: HttpStatusCode,
+    problem?: Partial<Omit<ProblemDetails, "status" | "title">>
+  ): ProblemDetails;
+}
+
+/* Excluded from this release type: HttpStatusCode */
+
+declare type HttpStatusCodeRangeDefinition =
+  | "1XX"
+  | "2XX"
+  | "3XX"
+  | "4XX"
+  | "5XX";
+
+/* Excluded from this release type: httpStatuses */
+
+/* Excluded from this release type: InboundPolicy */
+
+/**
+ * @public
+ * A policy that can modify the incoming HTTP request before it is sent to
+ * the handler. If a response is returned, the request is short-circuited and
+ * the response is returned to the client. If a Request is returned, policies
+ * or a handler that follow are executed.
+ *
+ * @param request - The incoming Request
+ * @param context - The current context of the Request
+ * @param options - The configuration options for the policy
+ * @param policyName - The name set on the policy in the configuration
+ * @returns A Response or Request object
+ */
+export declare interface InboundPolicyHandler<TOptions = any> {
+  (
+    request: ZuploRequest,
+    context: ZuploContext,
+    options: TOptions,
+    policyName: string
+  ): Promise<ZuploRequest | Response>;
+}
+
+declare interface IncludeMetrics {
+  country?: boolean;
+  httpMethod?: boolean;
+  statusCode?: boolean;
+  path?: boolean;
+}
+
+declare interface IncomingRequestProperties {
+  /**
+   * ASN of the incoming request, for example, 395747.
+   */
+  readonly asn: number | undefined;
+  /**
+   * The organization which owns the ASN of the incoming request,
+   * for example, Google Cloud.
+   */
+  readonly asOrganization: string | undefined;
+  /**
+   * City of the incoming request, for example, "Austin".
+   */
+  readonly city: string | undefined;
+  /**
+   * Continent of the incoming request, for example, "NA".
+   */
+  readonly continent: ContinentCode | undefined;
+  /**
+   * The two-letter country code in the request.
+   * @see {@link https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2|ISO 3166-1 alpha-2}
+   */
+  readonly country: Iso3166Alpha2Code | undefined;
+  /**
+   * Latitude of the incoming request, for example, "30.27130".
+   */
+  readonly latitude: string | undefined;
+  /**
+   * Longitude of the incoming request, for example, "-97.74260".
+   */
+  readonly longitude: string | undefined;
+  /**
+   * The three-letter IATA airport code of the data center that the request hit,
+   * for example, "DFW".
+   * @see {@link https://en.wikipedia.org/wiki/IATA_airport_code|IATA airport code}
+   */
+  readonly colo: string | undefined;
+  /**
+   * Postal code of the incoming request, for example, "78701".
+   */
+  readonly postalCode: string | undefined;
+  /**
+   * Metro code (DMA) of the incoming request, for example, "635".
+   */
+  readonly metroCode: string | undefined;
+  /**
+   * If known, the ISO 3166-2 name for the first level region associated with
+   * the IP address of the incoming request, for example, "Texas".
+   * @see {@link https://en.wikipedia.org/wiki/ISO_3166-2|ISO 3166-2}
+   */
+  readonly region: string | undefined;
+  /**
+   * If known, the ISO 3166-2 code for the first-level region associated with
+   * the IP address of the incoming request, for example, "TX".
+   * @see {@link https://en.wikipedia.org/wiki/ISO_3166-2|ISO 3166-2}
+   */
+  readonly regionCode: string | undefined;
+  /**
+   * Timezone of the incoming request, for example, "America/Chicago".
+   */
+  readonly timezone: string | undefined;
+}
+
+/* Excluded from this release type: IRequestProcessor */
+
+/** ISO 3166-1 Alpha-2 codes */
+declare type Iso3166Alpha2Code =
+  | "AD"
+  | "AE"
+  | "AF"
+  | "AG"
+  | "AI"
+  | "AL"
+  | "AM"
+  | "AO"
+  | "AQ"
+  | "AR"
+  | "AS"
+  | "AT"
+  | "AU"
+  | "AW"
+  | "AX"
+  | "AZ"
+  | "BA"
+  | "BB"
+  | "BD"
+  | "BE"
+  | "BF"
+  | "BG"
+  | "BH"
+  | "BI"
+  | "BJ"
+  | "BL"
+  | "BM"
+  | "BN"
+  | "BO"
+  | "BQ"
+  | "BR"
+  | "BS"
+  | "BT"
+  | "BV"
+  | "BW"
+  | "BY"
+  | "BZ"
+  | "CA"
+  | "CC"
+  | "CD"
+  | "CF"
+  | "CG"
+  | "CH"
+  | "CI"
+  | "CK"
+  | "CL"
+  | "CM"
+  | "CN"
+  | "CO"
+  | "CR"
+  | "CU"
+  | "CV"
+  | "CW"
+  | "CX"
+  | "CY"
+  | "CZ"
+  | "DE"
+  | "DJ"
+  | "DK"
+  | "DM"
+  | "DO"
+  | "DZ"
+  | "EC"
+  | "EE"
+  | "EG"
+  | "EH"
+  | "ER"
+  | "ES"
+  | "ET"
+  | "FI"
+  | "FJ"
+  | "FK"
+  | "FM"
+  | "FO"
+  | "FR"
+  | "GA"
+  | "GB"
+  | "GD"
+  | "GE"
+  | "GF"
+  | "GG"
+  | "GH"
+  | "GI"
+  | "GL"
+  | "GM"
+  | "GN"
+  | "GP"
+  | "GQ"
+  | "GR"
+  | "GS"
+  | "GT"
+  | "GU"
+  | "GW"
+  | "GY"
+  | "HK"
+  | "HM"
+  | "HN"
+  | "HR"
+  | "HT"
+  | "HU"
+  | "ID"
+  | "IE"
+  | "IL"
+  | "IM"
+  | "IN"
+  | "IO"
+  | "IQ"
+  | "IR"
+  | "IS"
+  | "IT"
+  | "JE"
+  | "JM"
+  | "JO"
+  | "JP"
+  | "KE"
+  | "KG"
+  | "KH"
+  | "KI"
+  | "KM"
+  | "KN"
+  | "KP"
+  | "KR"
+  | "KW"
+  | "KY"
+  | "KZ"
+  | "LA"
+  | "LB"
+  | "LC"
+  | "LI"
+  | "LK"
+  | "LR"
+  | "LS"
+  | "LT"
+  | "LU"
+  | "LV"
+  | "LY"
+  | "MA"
+  | "MC"
+  | "MD"
+  | "ME"
+  | "MF"
+  | "MG"
+  | "MH"
+  | "MK"
+  | "ML"
+  | "MM"
+  | "MN"
+  | "MO"
+  | "MP"
+  | "MQ"
+  | "MR"
+  | "MS"
+  | "MT"
+  | "MU"
+  | "MV"
+  | "MW"
+  | "MX"
+  | "MY"
+  | "MZ"
+  | "NA"
+  | "NC"
+  | "NE"
+  | "NF"
+  | "NG"
+  | "NI"
+  | "NL"
+  | "NO"
+  | "NP"
+  | "NR"
+  | "NU"
+  | "NZ"
+  | "OM"
+  | "PA"
+  | "PE"
+  | "PF"
+  | "PG"
+  | "PH"
+  | "PK"
+  | "PL"
+  | "PM"
+  | "PN"
+  | "PR"
+  | "PS"
+  | "PT"
+  | "PW"
+  | "PY"
+  | "QA"
+  | "RE"
+  | "RO"
+  | "RS"
+  | "RU"
+  | "RW"
+  | "SA"
+  | "SB"
+  | "SC"
+  | "SD"
+  | "SE"
+  | "SG"
+  | "SH"
+  | "SI"
+  | "SJ"
+  | "SK"
+  | "SL"
+  | "SM"
+  | "SN"
+  | "SO"
+  | "SR"
+  | "SS"
+  | "ST"
+  | "SV"
+  | "SX"
+  | "SY"
+  | "SZ"
+  | "TC"
+  | "TD"
+  | "TF"
+  | "TG"
+  | "TH"
+  | "TJ"
+  | "TK"
+  | "TL"
+  | "TM"
+  | "TN"
+  | "TO"
+  | "TR"
+  | "TT"
+  | "TV"
+  | "TW"
+  | "TZ"
+  | "UA"
+  | "UG"
+  | "UM"
+  | "US"
+  | "UY"
+  | "UZ"
+  | "VA"
+  | "VC"
+  | "VE"
+  | "VG"
+  | "VI"
+  | "VN"
+  | "VU"
+  | "WF"
+  | "WS"
+  | "YE"
+  | "YT"
+  | "ZA"
+  | "ZM"
+  | "ZW";
+
+/* Excluded from this release type: isRestrictedEnvVariableName */
+
+export declare function isZuploReadableEnvVariableName(name: string): boolean;
+
+/**
+ * Validates that the JWT token includes specific scopes
+ *
+ * @title JWT Scope Validation
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const JWTScopeValidationInboundPolicy: InboundPolicyHandler<JWTScopeValidationInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface JWTScopeValidationInboundPolicyOptions {
+  /**
+   * An array of of JWT scopes.
+   */
+  scopes: string[];
+}
+
+/* Excluded from this release type: KevValueStoreGetOptions */
+
+/* Excluded from this release type: KeyValueStore */
+
+/* Excluded from this release type: KeyValueStorePutOptions */
+
+/* Excluded from this release type: LogEntry */
+
+declare interface LogField {
+  name: string;
+  content: Primitive;
+}
+
+/* Excluded from this release type: LogFormat */
+
+/* Excluded from this release type: Logger */
+
+/* Excluded from this release type: LoggingContext */
+
+declare interface LogInsightLogEntry {
+  text: string;
+  timestamp: number;
+  fields: LogField[];
+}
+
+/* Excluded from this release type: LogLevel */
+
+/* Excluded from this release type: LogOwnerType */
+
+declare abstract class LogPlugin extends RuntimePlugin {
+  /* Excluded from this release type: getTransport */
+}
+
+declare type LogSourceType = "runtime" | "request";
+
+/* Excluded from this release type: LogTransport */
+
+export declare class LokiLoggingPlugin extends LogPlugin {
+  private options;
+  constructor(options: LokiLoggingPluginOptions);
+  /* Excluded from this release type: getTransport */
+}
+
+declare interface LokiLoggingPluginOptions {
+  url: string;
+  username: string;
+  password: string;
+}
+
+/* Excluded from this release type: LookupResult */
+
+export declare class MemoryZoneReadThroughCache<T = unknown> {
+  #private;
+  constructor(name: string, context: ZuploContext);
+  get(key: string): Promise<T | undefined>;
+  put(key: string, data: T, ttlSeconds: number): void;
+}
+
+/* Excluded from this release type: MeteringPlugin */
+
+/* Excluded from this release type: MeteringRegions */
+
+/* Excluded from this release type: MeteringSubscription */
+
+/* Excluded from this release type: MeteringSubscriptionStatus */
+
+/* Excluded from this release type: MetricsData */
+
+declare abstract class MetricsPlugin extends RuntimePlugin {
+  /* Excluded from this release type: getTransport */
+}
+
+declare interface MetricsTransport {
+  pushMetrics(entry: MetricsData, context: ZuploContext): void;
+}
+
+declare interface MetricsType {
+  latency?: boolean;
+  requestContentLength?: boolean;
+  responseContentLength?: boolean;
+}
+
+/**
+ * The options for this policy.
+ */
+export declare interface MockApiInboundOptions {
+  /**
+   * Indicates whether the response should be selected randomly, from the available examples (that match any filter criteria). If `false` the first matching example is used.
+   */
+  random?: boolean;
+  /**
+   * Specifies a prefix to match the responses to select from. Typically this is a status code like "200" or "2XX". If you want the policy to select randomly from all 2XX codes, set this property to "2" and random to `true`.
+   */
+  responsePrefixFilter?: string;
+  /**
+   * Specify the content-type of the response to select from. If not specified, the first matching response is used (or random).
+   */
+  contentType?: string;
+  /**
+   * Specify the name of the example to select. If not specified, the first matching response is used (or random).
+   */
+  exampleName?: string;
+}
+
+/**
+ * Returns example responses from the OpenAPI document associated with this route.
+ *
+ * @title Mock API Response
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const MockApiInboundPolicy: InboundPolicyHandler<MockApiInboundOptions>;
+
+declare type Modify<T, R> = Omit<T, keyof R> & R;
+
+declare interface MoesifContext {
+  apiVersion?: string;
+  userId?: string;
+  companyId?: string;
+  sessionToken?: string;
+  metadata?: unknown;
+}
+
+/**
+ * Moesif is an API analytics and billing service. This policy allows you to send metering calls for each API to their events batch endpoint.
+ *
+ * @remarks
+ * Moesif {@link https://moesif.com|moesif.com} is an API analytics and monetization
+ * platform. This policy allows you to measure (and meter) API calls flowing
+ * through your Zuplo gateway.
+ *
+ * Add the policy to each route you want to meter. Note you can specify the Meter
+ * API Name and Meter Value (meter increment) at the policy level.
+ *
+ * @title Moesif Analytics & Billing
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare function MoesifInboundPolicy(
+  request: ZuploRequest,
+  context: ZuploContext,
+  passedOptions: MoesifInboundPolicyOptions,
+  policyName: string
+): Promise<ZuploRequest<RequestGeneric>>;
+
+/**
+ * The options for this policy. Many of them can be overridden at the code level in a request using the `AmberfloMeteringPolicy.setRequestProperties` method.
+ */
+export declare interface MoesifInboundPolicyOptions {
+  /**
+   * Your Moesif application ID.
+   */
+  applicationId: string;
+  /**
+   * Set to false to disable sending the request body to Moesif.
+   */
+  logRequestBody?: boolean;
+  /**
+   * Set to false to disable sending the response body to Moesif.
+   */
+  logResponseBody?: boolean;
+}
+
+/* Excluded from this release type: MonetizationInboundPolicy */
+
+/**
+ * The options for this policy.
+ */
+export declare interface MonetizationInboundPolicyOptions {
+  /**
+   * Indicates if requests without subscription should be allowed or not.
+   */
+  allowRequestsWithoutSubscription?: boolean;
+  /**
+   * Indicates which subscription statuses should be allowed.
+   */
+  allowedSubscriptionStatuses?: (
+    | "active"
+    | "inactive"
+    | "incomplete"
+    | "incomplete-expired"
+    | "trialing"
+    | "past-due"
+    | "canceled"
+    | "unpaid"
+  )[];
+  /**
+   * Indicates the bucket to be used, overrides the default one.
+   */
+  bucketId?: string;
+  /**
+   * Indicates if requests over quota should be allowed or not.
+   */
+  allowRequestsOverQuota?: boolean;
+  /**
+   * The meters to be used by the policy against the subscription quota.
+   */
+  meters: {
+    /**
+     * This interface was referenced by `undefined`'s JSON-Schema definition
+     * via the `patternProperty` "^.*$".
+     */
+    [k: string]: number;
+  };
+  /**
+   * A list of successful status codes and ranges "200-299, 304" that should trigger a metering call.
+   */
+  meterOnStatusCodes?: string | number[];
+}
+
+declare type MonetizationPolicyMeters = {
+  [Key in string]: number;
+};
+
+/* Excluded from this release type: MonetizationSubscription */
+
+declare interface NotFoundOptions {
+  routesMatchedByPathOnly: RouteConfiguration[];
+}
+
+/**
+ * Authenticate users using Okta issued JWT tokens.
+ *
+ * @remarks
+ * Authenticate requests with JWT tokens issued by Okta. This is a customized
+ * version of the {@link https://zuplo.com/docs/policies/open-id-jwt-auth-inbound|OpenId JWT Policy} specifically
+ * for Okta.
+ *
+ * See {@link https://zuplo.com/docs/articles/oauth-authentication|this document} for more information
+ * about OAuth authorization in Zuplo.
+ *
+ * @title Okta JWT Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const OktaJwtInboundPolicy: InboundPolicyHandler<OktaJwtInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface OktaJwtInboundPolicyOptions {
+  /**
+   * Allow unauthenticated requests to proceed. This is use useful if you want to use multiple authentication policies or if you want to allow both authenticated and non-authenticated traffic.
+   */
+  allowUnauthenticatedRequests?: boolean;
+  /**
+   * Your Okta authorization server's issuer URL. For example, `https://dev-12345.okta.com/oauth2/abc`.
+   */
+  issuerUrl: string;
+  /**
+   * The Okta audience of your API, for example `api://my-api`.
+   */
+  audience?: string;
+}
+
+/**
+ * @public
+ */
+declare interface OnRequestHook {
+  (
+    request: ZuploRequest,
+    context: ZuploContext
+  ): Promise<ZuploRequest | Response> | (ZuploRequest | Response);
+}
+
+/**
+ * @public
+ */
+declare interface OnResponseSendingFinalHook {
+  (
+    response: Response,
+    request: ZuploRequest,
+    context: ZuploContext
+  ): Promise<void> | void;
+}
+
+/**
+ * @public
+ */
+declare interface OnResponseSendingHook {
+  (
+    response: Response,
+    request: ZuploRequest,
+    context: ZuploContext
+  ): Promise<Response> | Response;
+}
+
+declare interface OnSendingAwsLambdaEventHook {
+  (
+    request: ZuploRequest,
+    context: ZuploContext,
+    event: AwsLambdaEventV1 | AwsLambdaEventV2
+  ): Promise<AwsLambdaEventV1 | AwsLambdaEventV2>;
+}
+
+/* Excluded from this release type: openApiSpecHandler */
+
+/**
+ * The Open ID JWT Authentication policy allows you to authenticate incoming requests using an Open ID compliant bearer token.
+ *
+ * @remarks
+ * The Open ID JWT Authentication policy allows you to authenticate incoming
+ * requests using an Open ID-compliant bearer token. It works with common
+ * authentication services like Auth0 (sample here) but should also work with any
+ * valid Open ID JWT token.
+ *
+ * When configured, you can have Zuplo check incoming requests for a JWT token and
+ * automatically populate the `ZuploRequest` 's `user` property with a user object.
+ * This `user` object will have a `sub` property - taking the `sub` id from the JWT
+ * token. It will also have a `data` property populated by other data returned in
+ * the JWT token (including any claims).
+ *
+ * See {@link https://zuplo.com/docs/articles/oauth-authentication|this document} for more information
+ * about OAuth authorization in Zuplo.
+ *
+ * @title JWT Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const OpenIdJwtInboundPolicy: InboundPolicyHandler<OpenIdJwtInboundPolicyInternalOptions>;
+
+declare interface OpenIdJwtInboundPolicyInternalOptions
+  extends Omit<OpenIdJwtInboundPolicyOptions, "secret"> {
+  secret?: string | KeyLike;
+}
+
+/**
+ * The options for this policy.
+ */
+export declare interface OpenIdJwtInboundPolicyOptions {
+  /**
+   * The expected issuer claim in the JWT token.
+   */
+  issuer?: string;
+  /**
+   * The expected audience claim in the JWT token.
+   */
+  audience?: string;
+  /**
+   * the url of the JSON Web Key Set (JWKS) - this is used to validate the JWT token signature (either this or `secret` must be set).
+   */
+  jwkUrl?: string;
+  /**
+   * The key used to verify the signature of the JWT token (either this or `jwkUrl` must be set).
+   */
+  secret?: string;
+  /**
+   * indicates whether the request should continue if authentication fails. Defaults is `false` which means unauthenticated users will automatically receive a 401 response.
+   */
+  allowUnauthenticatedRequests?: boolean;
+  /**
+   * The name of the property in the JWT token that contains the user's unique identifier.
+   */
+  subPropertyName?: string;
+  /**
+   * Additional headers to send with the JWK request.
+   */
+  headers?: {
+    [k: string]: string;
+  };
+}
+
+export declare const originalFetch: typeof fetch;
+
+/* Excluded from this release type: OutboundPolicy */
+
+/**
+ * @public
+ * A policy that can modify the outgoing HTTP response before it is returned
+ * to the client.
+ *
+ * @param response - The outgoing Response
+ * @param request - The incoming Request
+ * @param context - The current context of the Request
+ * @param options - The configuration options for the policy
+ * @param policyName - The name set on the policy in the configuration
+ * @returns A Response object
+ */
+export declare interface OutboundPolicyHandler<TOptions = any> {
+  (
+    response: Response,
+    request: ZuploRequest,
+    context: ZuploContext,
+    options: TOptions,
+    policyName: string
+  ): Promise<Response>;
+}
+
+/* Excluded from this release type: ParameterBaseObject */
+
+/* Excluded from this release type: ParameterDefinition */
+
+/**
+ * This is the parsed values of the Cors configuration. All
+ * values in the parsed configuration are in the format that the headers
+ * use them (i.e. everything is converted to a string)
+ */
+declare interface ParsedCorsPolicyConfiguration {
+  name: string;
+  allowCredentials: string | undefined;
+  maxAge: string | undefined;
+  allowedOrigins: string[];
+  allowedMethods?: string;
+  allowedHeaders?: string;
+  exposeHeaders?: string;
+}
+
+declare interface ParsedRouteData extends Omit<RouteData, "corsPolicies"> {
+  corsPolicies: ParsedCorsPolicyConfiguration[];
+}
+
+/* Excluded from this release type: PolicyBase */
+
+export declare interface PolicyConfiguration {
+  name: string;
+  policyType: string;
+  handler: HandlerDefinition;
+  options?: unknown;
+}
+
+declare type Primitive =
+  | null
+  | undefined
+  | string
+  | number
+  | boolean
+  | symbol
+  | bigint;
+
+/* Excluded from this release type: ProblemDetails */
+
+/* Excluded from this release type: ProblemResponseDetails */
+
+/* Excluded from this release type: ProblemResponseFormat */
+
+/* Excluded from this release type: ProblemResponseFormatter */
+
+/**
+ * Authenticate users using PropelAuth issued JWT tokens.
+ *
+ * @remarks
+ * Authenticate requests with JWT tokens issued by {@link https://propelauth.com|PropelAuth}.
+ * This is a customized version of the {@link https://zuplo.com/docs/policies/open-id-jwt-auth-inbound|OpenId JWT Policy}
+ * specifically for PropelAuth.
+ *
+ * @title PropelAuth JWT Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const PropelAuthJwtInboundPolicy: InboundPolicyHandler<PropelAuthJwtInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface PropelAuthJwtInboundPolicyOptions {
+  /**
+   * Allow unauthenticated requests to proceed. This is use useful if you want to use multiple authentication policies or if you want to allow both authenticated and non-authenticated traffic.
+   */
+  allowUnauthenticatedRequests?: boolean;
+  /**
+   * Your PropelAuth authUrl. For example, `https://6587563.propelauthtest.com`.
+   */
+  authUrl: string;
+  /**
+   * Your public (verifier) key that is used to verify access tokens. This key has a value that begins with '-----BEGIN PUBLIC KEY-----'. Make sure to remove all line breaks from the key before saving the variable.
+   */
+  verifierKey: string;
+}
+
+/* Excluded from this release type: purgeGatewayCache */
+
+/**
+ * The identifying element of the request that enforces distinct rate limits. For example, you can limit by `user`, `ip`, `function` or `all` - function allows you to specify a simple function to create a string identifier to create a rate-limit group.
+ */
+declare type RateLimitByType = "user" | "ip" | "function" | "all";
+
+/**
+ * Adds the retry-after header.
+ */
+declare type RateLimitHeaderMode = "none" | "retry-after";
+
+/**
+ * The rate-limiting policy is used to limit the number of requests that can be made against your API based on a key.
+ *
+ * @remarks
+ * Rate-limiting allows you to set a maximum rate of requests for your API gateway.
+ * This is useful to enforce rate limits agreed with your clients and protect your
+ * downstream services.
+ *
+ * The Zuplo Rate-Limit allows you to limit based on different attributes of the
+ * incoming request. For example, you might set a rate limit of 10 requests per
+ * second per user, or 20 requests per second for a given IP address.
+ *
+ * The Zuplo rate-limiter also allows you to set a custom bucket name by which to
+ * effect a rate-limit using a function.
+ *
+ * When a client reaches a rate limit - they will receive a `429` response code.
+ *
+ * @title Rate Limiting
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+declare const RateLimitInboundPolicy: InboundPolicyHandler<RateLimitInboundPolicyOptions>;
+export { RateLimitInboundPolicy as BasicRateLimitInboundPolicy };
+export { RateLimitInboundPolicy };
+
+/**
+ * The options for this policy.
+ */
+declare interface RateLimitInboundPolicyOptions {
+  rateLimitBy: RateLimitByType;
+  /**
+   * The max number of requests allowed in the given time window.
+   */
+  requestsAllowed: number;
+  /**
+   * The time window in which the requests are rate-limited. The count restarts after each window expires.
+   */
+  timeWindowMinutes: number;
+  /**
+   * The function that returns dynamic configuration data. Used only with `rateLimitBy=function`.
+   */
+  identifier?: {
+    /**
+     * used only with rateLimitBy=function. Specifies the export to load your custom bucket function, e.g. `default`, `rateLimitIdentifier`.
+     */
+    export: string;
+    /**
+     * Specifies the module to load your custom bucket function, in the format `$import(./modules/my-module)`.
+     */
+    module: string;
+  };
+  headerMode?: RateLimitHeaderMode;
+  /**
+   * If true, the policy will throw an error in the event there is a problem connecting to the rate limit service.
+   */
+  throwOnFailure?: boolean;
+  mode?: RateLimitMode;
+}
+export { RateLimitInboundPolicyOptions as BasicRateLimitInboundPolicyOptions };
+export { RateLimitInboundPolicyOptions };
+
+/**
+ * The mode of the policy. If set to `async`, the policy will check if the request is over the rate limit without blocking. This can result in some requests allowed over the rate limit.
+ */
+declare type RateLimitMode = "strict" | "async";
+
+/**
+ * The options for this policy. Many of them can be overridden at the code level in a request using the `AmberfloMeteringPolicy.setRequestProperties` method.
+ */
+declare interface ReadmeMeteringInboundPolicyOptions {
+  /**
+   * The API key to use when sending metrics calls to Readme.
+   */
+  apiKey: string;
+  /**
+   * This is the path to the property on `request.user` that contains the label you want to use. For example `.data.accountNumber` would read the `request.user.data.accountNumber` property.
+   */
+  userLabelPropertyPath?: string;
+  /**
+   * This is the path to the property on `request.user` that contains the e-mail of the user. For example `.data.email` would read the `request.user.data.email` property.
+   */
+  userEmailPropertyPath?: string;
+  /**
+   * Whether the data should be ingested as 'development' mode or not. Defaults to true for working-copy and false for all other environments.
+   */
+  development?: boolean;
+  /**
+   * When true, Zuplo sends the full request path (which might contain sensitive information). By default, we only send the route path which should not contain sensitive information.
+   */
+  useFullRequestPath?: boolean;
+  /**
+   * The URL to send metering events. This is useful for testing purposes.
+   */
+  url?: string;
+}
+
+/**
+ * Readme is a developer documentation and API metrics company. This policy pushes logs to their API calls dashboard.
+ *
+ * @remarks
+ * {@link https://readme.com|Readme} is a developer Documentation and
+ * metrics service. This policy pushes the request/response data to their ingestion
+ * endpoint so you can see your Zuplo API traffic in their API calls dashboard.
+ *
+ * @title Readme Metrics
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare function ReadmeMetricsInboundPolicy(
+  request: ZuploRequest,
+  context: ZuploContext,
+  options: ReadmeMeteringInboundPolicyOptions,
+  policyName: string
+): Promise<ZuploRequest<RequestGeneric>>;
+
+/* Excluded from this release type: redirectHandler */
+
+/**
+ * Remove headers from the incoming request.
+ *
+ * @title Remove Request Headers
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const RemoveHeadersInboundPolicy: InboundPolicyHandler<RemoveHeadersInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface RemoveHeadersInboundPolicyOptions {
+  /**
+   * An array of headers to remove from the incoming request.
+   */
+  headers: string[];
+}
+
+/**
+ * Remove configured headers from the outgoing response.
+ *
+ * @title Remove Response Headers
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const RemoveHeadersOutboundPolicy: OutboundPolicyHandler<RemoveHeadersOutboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface RemoveHeadersOutboundPolicyOptions {
+  /**
+   * An array of headers to be removed from the outgoing response.
+   */
+  headers: string[];
+}
+
+/**
+ * Remove query parameters from the incoming request
+ *
+ * @title Remove Query Parameters
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const RemoveQueryParamsInboundPolicy: InboundPolicyHandler<RemoveQueryParamsInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface RemoveQueryParamsInboundPolicyOptions {
+  /**
+   * An array of query parameters to be removed from the incoming request.
+   */
+  params: string[];
+}
+
+/**
+ * Replace a string in the incoming request body
+ *
+ * @title Replace String in Response Body
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const ReplaceStringOutboundPolicy: OutboundPolicyHandler<ReplaceStringOutboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface ReplaceStringOutboundPolicyOptions {
+  /**
+   * The type of string replacement to perform.
+   */
+  mode: "regexp" | "string";
+  /**
+   * The pattern to match.
+   */
+  match: string;
+  /**
+   * The value to each match is replaced with.
+   */
+  replaceWith: string;
+}
+
+/**
+ * The types of the properties in a request
+ * @public
+ */
+declare interface RequestGeneric extends RequestInitGeneric {
+  Query?: RequestQueryDefault;
+}
+
+/**
+ * The types of the properties in a request init object
+ * @public
+ */
+declare interface RequestInitGeneric {
+  UserData?: UserDataDefault;
+  Params?: RequestParamsDefault;
+}
+
+declare type RequestParamsDefault = Record<string, string>;
+
+declare type RequestQueryDefault = Record<string, string>;
+
+/**
+ * Enforces a maximum size in bytes of the incoming request.
+ *
+ * @title Request Size Limit
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const RequestSizeLimitInboundPolicy: InboundPolicyHandler<RequestSizeLimitInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface RequestSizeLimitInboundPolicyOptions {
+  /**
+   * The maximum size of the request in bytes.
+   */
+  maxSizeInBytes: number;
+  /**
+   * If true, the policy will reject any request with a `content-length` header in excess of `maxSizeInBytes` bytes value, but will not verify the actual size of the request. This is more efficient and offers slightly better memory usage but should only be used if you trust/control the clients calling the gateway to send an accurate content-length. If false, the gateway will actually verify the request size and reject any request with a size in excess of the stated maximum.
+   */
+  trustContentLengthHeader?: boolean;
+}
+
+/**
+ * The authorized identity on the incoming request
+ * @public
+ */
+export declare interface RequestUser<TUserData> {
+  sub: string;
+  data: TUserData;
+}
+
+/**
+ * Validate inbound requests based on Open API specification
+ *
+ * @remarks
+ * The Request Validation policy is used to validate incoming requests based on
+ * schemas in OpenAPI specifications.
+ *
+ * When configured, any requests that do not conform to your OpenAPI schema will be
+ * rejected with a `400: Bad Request` response containing a detailed error message
+ * (in JSON) explaining why the request was not accepted.
+ *
+ * @title Request Validation
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const RequestValidationInboundPolicy: InboundPolicyHandler<RequestValidationInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface RequestValidationInboundPolicyOptions {
+  /**
+   * The log level to use when logging validation errors.
+   */
+  logLevel?: "error" | "warn" | "info" | "debug";
+  validateBody?: ValidationOptions;
+  validateQueryParameters?: ValidationOptions1;
+  validatePathParameters?: ValidationOptions2;
+  validateHeaders?: ValidationOptions3;
+  /**
+   * Whether to include the request in the logs.
+   */
+  includeRequestInLogs?: boolean;
+}
+
+/**
+ * Sets an allow-list for an origin header
+ *
+ * @remarks
+ * The Require Origin policy is used to enforce that the client is sending an
+ * `origin` header that matches your allow-list specified in the policy options.
+ *
+ * This is useful if you want to stop any browser traffic from different domains.
+ *
+ * However, it is important to note that it does not guarantee that traffic is only
+ * coming from a browser. Somebody could simulate a browser request from a backend
+ * server and set any origin they like.
+ *
+ * If the incoming origin is missing, or not allowed - a 400 Forbidden Problem
+ * Response will be sent to the client. You can customize the `detail` property in
+ * the policy options.
+ *
+ * @title Require Origin
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const RequireOriginInboundPolicy: InboundPolicyHandler<RequireOriginInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface RequireOriginInboundPolicyOptions {
+  /**
+   * A comma separated string containing valid origins.
+   */
+  origins: string;
+  /**
+   * The `detail` of the HTTP Problem response, if the origin is missing or disallowed.
+   */
+  failureDetail?: string;
+}
+
+declare type ResolveRequestParams<
+  TParams extends RequestParamsDefault | undefined,
+> = TParams extends RequestParamsDefault ? TParams : RequestParamsDefault;
+
+declare type ResolveRequestQuery<
+  TQuery extends RequestQueryDefault | undefined,
+> = TQuery extends RequestQueryDefault ? TQuery : RequestQueryDefault;
+
+declare type ResolveUserData<TUserData extends UserDataDefault | undefined> =
+  TUserData extends UserDataDefault ? TUserData : UserDataDefault;
+
+/* Excluded from this release type: ResponsesDefinition */
+
+/* Excluded from this release type: ResponseSendingEvent */
+
+/* Excluded from this release type: ResponseSentEvent */
+
+export declare interface RouteConfiguration
+  extends Omit<BuildRouteConfiguration, "raw"> {
+  /**
+   * @deprecated Please switch to "raw().operationId"
+   */
+  operationId?: string;
+  /**
+   * @deprecated Please switch to "raw().summary"
+   */
+  summary?: string;
+  /**
+   * @deprecated Please switch to "raw().tags"
+   */
+  tags?: string[];
+  /**
+   * @deprecated Please switch to "raw().parameters"
+   */
+  parameters?: ParameterDefinition[];
+  /**
+   * @deprecated Please switch to "raw().responses"
+   */
+  responses?: ResponsesDefinition;
+  raw<T>(): T;
+}
+
+export declare interface RouteData {
+  /**
+     /* @deprecated This property is not used and will be removed in future versions
+     */
+  info?: OpenAPIV3_1.InfoObject;
+  /**
+     /* @deprecated This property is not used and will be removed in future versions
+     */
+  versions: VersionData[];
+  /**
+   * @minItems 0
+   */
+  routes: RouteConfiguration[];
+  policies?: PolicyConfiguration[];
+  corsPolicies?: CorsPolicyConfiguration[];
+  requestErrorHandler?: HandlerDefinition;
+}
+
+/* Excluded from this release type: RouteHandler */
+
+/* Excluded from this release type: Router */
+
+/* Excluded from this release type: RouterEntry */
+
+/* Excluded from this release type: RuntimeEnvironment */
+
+/**
+ * Used to indicate errors that are caused by user input
+ * These errors are shown to the user and logged in user logs
+ * These errors are NOT fatal and will not cause monitoring alerts
+ * @public
+ */
+export declare class RuntimeError extends Error {
+  extensionMembers: Record<string, unknown> | undefined;
+  constructor(message: string, options?: ErrorOptions);
+  constructor(
+    info: {
+      message: string;
+      extensionMembers?: Record<string, unknown>;
+    },
+    options?: ErrorOptions
+  );
+}
+
+/* Excluded from this release type: RuntimeExtensions */
+
+export declare interface RuntimeExtensionsFunction {
+  (runtime: RuntimeExtensions): Promise<void>;
+}
+
+declare abstract class RuntimePlugin {}
+
+/* Excluded from this release type: RuntimeSettings */
+
+declare type RuntimeType = "deno" | "cloudflare";
+
+export declare function sanitizedIdentifierName(name: string): string;
+
+/**
+ * @deprecated Use RequestValidationInboundPolicy instead
+ */
+export declare const SchemaBasedRequestValidation: InboundPolicyHandler<RequestValidationInboundPolicyOptions>;
+
+/* Excluded from this release type: serialize */
+
+/* Excluded from this release type: ServiceProvider */
+
+/* Excluded from this release type: ServiceProviderImpl */
+
+/**
+ * Sets the body of the request in the inbound pipeline - make sure to convert a GET/HEAD request to another method when using this policy.
+ *
+ * @remarks
+ * The Set Body policy allows you to set or override the incoming request body.
+ * {@link https://zuplo.com/docs/articles/zp-body-removed|GET or HEAD requests do not support bodies on Zuplo},
+ * so be sure to use the {@link https://zuplo.com/docs/policies/change-method-inbound|Change Method}
+ * policy to update the method to a `POST` or whatever is appropriate. You might
+ * also need to use the {@link https://zuplo.com/docs/policies/set-headers-inbound|Set Header} policy to
+ * set a `content-type`.
+ *
+ * @title Set Body
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const SetBodyInboundPolicy: InboundPolicyHandler<SetBodyInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface SetBodyInboundPolicyOptions {
+  /**
+   * The value to set for the body.
+   */
+  body: string;
+}
+
+/**
+ * Adds or sets headers on the incoming request.
+ *
+ * @remarks
+ * The set header policy adds a header to the request in the inbound pipeline. This
+ * can be used to set a security header required by the downstream service.
+ *
+ * @title Add or Set Request Headers
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const SetHeadersInboundPolicy: InboundPolicyHandler<SetHeadersInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface SetHeadersInboundPolicyOptions {
+  /**
+   * An array of headers to set in the request. By default, headers will be overwritten if they already exists in the request, specify the overwrite property to change this behavior.
+   */
+  headers: {
+    /**
+     * The name of the header.
+     */
+    name: string;
+    /**
+     * The value of the header.
+     */
+    value: string;
+    /**
+     * Overwrite the value if the header is already present in the request.
+     */
+    overwrite?: boolean;
+  }[];
+}
+
+/**
+ * Adds or sets headers on the on the outgoing response.
+ *
+ * @title Set Headers
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const SetHeadersOutboundPolicy: OutboundPolicyHandler<SetHeadersOutboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface SetHeadersOutboundPolicyOptions {
+  /**
+   * An array of headers to set on the response. By default, headers will be overwritten if they already exists in the response, specify the overwrite property to change this behavior.
+   */
+  headers: {
+    /**
+     * The name of the header.
+     */
+    name: string;
+    /**
+     * The value of the header.
+     */
+    value: string;
+    /**
+     * Overwrite the value if the header is already present in the response.
+     */
+    overwrite?: boolean;
+  }[];
+}
+
+export declare function setMoesifContext(
+  context: ZuploContext,
+  moesifContext: MoesifContext
+): void;
+
+/**
+ * Adds or sets query parameters on the incoming request.
+ *
+ * @title Add or Set Query Parameters
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const SetQueryParamsInboundPolicy: InboundPolicyHandler<SetQueryParamsInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface SetQueryParamsInboundPolicyOptions {
+  /**
+   * An array of query params to set in the request. By default, query parameters will be overwritten if they already exist in the request, specify the overwrite property to change this behavior.
+   */
+  params: {
+    /**
+     * The name of the param.
+     */
+    name: string;
+    /**
+     * The value of the param.
+     */
+    value: string;
+    /**
+     * Overwrite the value if the param is already present in the request.
+     */
+    overwrite?: boolean;
+  }[];
+}
+
+/**
+ * Sets the status code on the on the outgoing response.
+ *
+ * @title Set Status Code
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const SetStatusOutboundPolicy: OutboundPolicyHandler<SetStatusOutboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface SetStatusOutboundPolicyOptions {
+  /**
+   * The status code to be used in the response.
+   */
+  status?: number;
+  /**
+   * The statusText to be used in the response.
+   */
+  statusText?: string;
+}
+
+/**
+ * Add a delay to the incoming request. Useful for testing.
+ *
+ * @title Sleep / Delay
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const SleepInboundPolicy: InboundPolicyHandler<SleepInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface SleepInboundPolicyOptions {
+  /**
+   * The number of milliseconds to delay the request.
+   */
+  sleepInMs: number;
+}
+
+/* Excluded from this release type: StandardEnv */
+
+/* Excluded from this release type: StripeMonetizationPlugin */
+
+/* Excluded from this release type: StripeMonetizationPluginOptions */
+
+/**
+ * The Stripe Webhook policy validates the authenticity of an incoming Stripe webhook.
+ *
+ * @remarks
+ * The Stripe Webhook policy secures your incoming webhooks by validating that
+ * the request was sent by Stripe.
+ *
+ * @title Stripe Webhook Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare class StripeWebhookVerificationInboundPolicy extends InboundPolicy<StripeWebhookVerificationInboundPolicyOptions> {
+  handler(
+    request: ZuploRequest,
+    context: ZuploContext
+  ): Promise<ZuploRequest<RequestGeneric> | Response>;
+}
+
+/**
+ * The options for this policy.
+ */
+export declare interface StripeWebhookVerificationInboundPolicyOptions {
+  /**
+   * The signing secret for the webhook.
+   */
+  signingSecret: string;
+  /**
+   * The allowed clock skew in seconds between the time the webhook signature was crated and the current time.
+   */
+  tolerance?: number;
+}
+
+/* Excluded from this release type: SubscriptionMeters */
+
+declare interface SumoLogicLoggingOptions {
+  url: string;
+  name?: string;
+  category?: string;
+}
+
+export declare class SumoLogicLoggingPlugin extends LogPlugin {
+  private options;
+  constructor(options: SumoLogicLoggingOptions);
+  /* Excluded from this release type: getTransport */
+}
+
+/**
+ * The Supabase JWT Authentication policy supports user JWT tokens created by Supabase.
+ *
+ * @remarks
+ * The Supabase JWT Authentication policy allows you to authenticate incoming
+ * requests using a token created by {@link https://supabase.com|supabase.com}.
+ *
+ * When configured, you can have Zuplo check incoming requests for a JWT token and
+ * automatically populate the `ZuploRequest`'s `user` property with a user object.
+ *
+ * This `user` object will have a `sub` property - taking the `sub` id from the JWT
+ * token. It will also have a `data` property populated by other data returned in
+ * the JWT token - including all your claims, `user_metadata` and `app_metadata`.
+ *
+ * You can also require specific claims to have specific values to allow
+ * authentication to complete, providing a layer of authorization.
+ *
+ * @title Supabase JWT Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const SupabaseJwtInboundPolicy: InboundPolicyHandler<SupabaseJwtInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface SupabaseJwtInboundPolicyOptions {
+  /**
+   * The key used to verify the signature of the JWT token.
+   */
+  secret: string;
+  /**
+   * Indicates whether the request should continue if authentication fails. Default is `false` which means unauthenticated users will automatically receive a 401 response.
+   */
+  allowUnauthenticatedRequests?: boolean;
+  /**
+   * Any claims that must be present for authentication to succeed - multiple valid values can be specified for each claim.
+   */
+  requiredClaims?: {
+    [k: string]: string[];
+  };
+}
+
+/* Excluded from this release type: SYSTEM_LOGGER */
+
+/* Excluded from this release type: SystemLogMap */
+
+/* Excluded from this release type: SystemRouteName */
+
+/* Excluded from this release type: SystemRuntimePlugin */
+
+/**
+ * Uses Azure Active Directory to add an Authorization header to the request in order to authenticate requests using Azure identity.
+ *
+ * @remarks
+ * This policy adds a `Authorization` header to the upstream request that allows
+ * using Azure AD to authenticate requests to your origin server. This is a useful
+ * means of securing your origin server so that only your Zuplo gateway can make
+ * requests against it.
+ *
+ * Using this policy allows you to delegate authentication and authorization to
+ * your gateway without writing any code on your origin service. For instructions
+ * on how to configure Azure AD authentication see
+ * {@link https://learn.microsoft.com/en-us/azure/app-service/configure-authentication-provider-aad | Configure your App Service or Azure Functions app to use Azure AD login}.
+ *
+ * @title Upstream Azure AD Service Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const UpstreamAzureAdServiceAuthInboundPolicy: InboundPolicyHandler<UpstreamAzureAdServiceAuthInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface UpstreamAzureAdServiceAuthInboundPolicyOptions {
+  /**
+   * Azure Active Directory Tenant ID.
+   */
+  activeDirectoryTenantId: string;
+  /**
+   * The Application (client) ID of the Azure AD App Registration.
+   */
+  activeDirectoryClientId: string;
+  /**
+   * The client secret of the Azure AD App Registration.
+   */
+  activeDirectoryClientSecret: string;
+  /**
+   * The number of times to retry fetching the token in the event of a failure..
+   */
+  tokenRetries?: number;
+  /**
+   * The number of seconds less than the token expiration to cache the token.
+   */
+  expirationOffsetSeconds?: number;
+}
+
+/**
+ * Creates a Firebase Admin token and attaches it to the outgoing request. Useful when calling Firebase services as an administrator.
+ *
+ * @remarks
+ * This policy adds a Firebase Admin token to the outgoing `Authentication` header
+ * allowing requests to Firebase using Service Account admin permissions. This can
+ * be useful for calling Firebase services such as Firestore through a Zuplo
+ * endpoint that is secured with other means of Authentication such as API keys.
+ * Additionally, this policy can be useful for service content to all API users
+ * (for example serving a specific Firestore document containing configuration
+ * data)
+ *
+ * We recommend reading the `serviceAccountJson` from environment variables (so it
+ * is not checked in to source control) using the `$env(ENV_VAR)` syntax.
+ *
+ * @title Upstream Firebase Admin Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const UpstreamFirebaseAdminAuthInboundPolicy: InboundPolicyHandler<UpstreamFirebaseAdminAuthInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface UpstreamFirebaseAdminAuthInboundPolicyOptions {
+  /**
+   * The Google Service Account key in JSON format. Note you can load this from environment variables using the $env(ENV_VAR) syntax.
+   */
+  serviceAccountJson: string;
+  /**
+   * The number of times to retry fetching the token in the event of a failure.
+   */
+  tokenRetries?: number;
+  /**
+   * The number of seconds less than the token expiration to cache the token.
+   */
+  expirationOffsetSeconds?: number;
+}
+
+/**
+ * Creates a Firebase custom user token and attaches it to the outgoing request. Useful when calling Firebase services as user.
+ *
+ * @remarks
+ * This policy adds a Firebase Admin token to the outgoing `Authentication` header
+ * allowing requests to Firebase using Service Account admin permissions. This can
+ * be useful for calling Firebase services such as Firestore through a Zuplo
+ * endpoint that is secured with other means of Authentication such as API keys.
+ * Additionally, this policy can be useful for service content to all API users
+ * (for example serving a specific Firestore document containing configuration
+ * data)
+ *
+ * We recommend reading the `serviceAccountJson` from environment variables (so it
+ * is not checked in to source control) using the `$env(ENV_VAR)` syntax.
+ *
+ * @title Upstream Firebase User Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const UpstreamFirebaseUserAuthInboundPolicy: InboundPolicyHandler<UpstreamFirebaseUserAuthInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface UpstreamFirebaseUserAuthInboundPolicyOptions {
+  /**
+   * The Google Service Account key in JSON format. Note you can load this from environment variables using the $env(ENV_VAR) syntax.
+   */
+  serviceAccountJson: string;
+  /**
+   * The userId to use as the custom token's subject.
+   */
+  userId?: string;
+  /**
+   * The property on the incoming request.user object to retrieve the value of the userId.
+   */
+  userIdPropertyPath?: string;
+  /**
+   * Additional claims to include in the custom token's payload.
+   */
+  developerClaims?: Record<string, string | number | boolean | null>;
+  /**
+   * The Firebase Web API Key (found in project settings)
+   * @see {@link https://firebase.google.com/docs/projects/api-keys|Firebase API Keys}.
+   */
+  webApiKey: string;
+  /**
+   * The number of times to retry fetching the token in the event of a failure.
+   */
+  tokenRetries?: number;
+  /**
+   * The number of seconds less than the token expiration to cache the token.
+   */
+  expirationOffsetSeconds?: number;
+}
+
+/**
+ * Creates a self-signed JWT token (generated using a Google Service Account JSON) and attaches it to the outgoing request. Useful when calling GCP services like Cloud Endpoints / ESPv2
+ *
+ * @remarks
+ * This policy adds a JWT token to the headers, ready for us in an outgoing request
+ * when calling a GCP service (e.g. Cloud Endpoints / ESPv2). We recommend reading
+ * the `serviceAccountJson` from environment variables (so it is not checked in to
+ * source control) using the `$env(ENV_VAR)` syntax.
+ *
+ * CAUTION: This policy only works with {@link https://developers.google.com/identity/protocols/oauth2/service-account#jwt-auth | certain Google APIs}.
+ * In most cases, the {@link https://zuplo.com/docs/policies/upstream-gcp-service-auth-inbound | Upstream GCP Service Auth}
+ * should be used.
+ *
+ * @title Upstream GCP Self-Signed JWT
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const UpstreamGcpJwtInboundPolicy: InboundPolicyHandler<UpstreamGcpJwtInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface UpstreamGcpJwtInboundPolicyOptions {
+  /**
+   * The audience for the minted JWT. See the document {@link https://cloud.google.com/endpoints/docs/grpc-service-config/reference/rpc/google.api#google.api.AuthRequirement|AuthRequirement} for details.
+   */
+  audience: string;
+  /**
+   * The Google Service Account key in JSON format. Note you can load this from environment variables using the $env(ENV_VAR) syntax.
+   */
+  serviceAccountJson: string;
+}
+
+/**
+ * Creates an ID Token from Google's OAuth service and attaches it to the outgoing request. Useful when calling GCP services or Google APIs that are secured with GCP IAM.
+ *
+ * @remarks
+ * This policy allows you to delegate authentication and authorization to your
+ * gateway without writing any code on your origin service by adding a GCP Issued
+ * ID Token to outgoing header allowing the service to be secured with GCP IAM.
+ * This is a useful means of securing your origin server so that only your Zuplo
+ * gateway can make requests against it.
+ *
+ *
+ * This policy works with
+ * {@link https://zuplo.com/docs/articles/gke-with-upstream-auth-policy|GCP Identity Aware Proxy}
+ * or services like {@link https://cloud.google.com/iap/docs/managing-access|Cloud Run}
+ * that natively support IAM authorization.
+ *
+ * We recommend reading the `serviceAccountJson` from environment variables (so it
+ * is not checked in to source control) using the `$env(ENV_VAR)` syntax.
+ *
+ * For information on how Google's service based auth works see {@link https://cloud.google.com/functions/docs/securing/authenticating|Authenticating for invocation}
+ *
+ * @title Upstream GCP Service Auth
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const UpstreamGcpServiceAuthInboundPolicy: InboundPolicyHandler<UpstreamGcpServiceAuthInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ */
+export declare interface UpstreamGcpServiceAuthInboundPolicyOptions {
+  /**
+   * The audience for the service to be called. This is typically the URL of your service endpoint like 'https://my-service-a2ev-uc.a.run.app'. If calling a Google API, leave this empty.
+   */
+  audience?: string;
+  /**
+   * The scopes to grant the access token. See {@link https://developers.google.com/identity/protocols/oauth2/scopes|documentation} for details. This is only set with calling a Google API. If calling a service like Cloud Run, etc. leave this empty.
+   */
+  scopes?: string[];
+  /**
+   * The Google Service Account key in JSON format. Note you can load this from environment variables using the `$env(ENV_VAR)` syntax.
+   * @see {@link https://developers.google.com/workspace/guides/create-credentials|Create access credentials}.
+   */
+  serviceAccountJson: string;
+  /**
+   * The number of times to retry fetching the token in the event of a failure.
+   */
+  tokenRetries?: number;
+  /**
+   * The number of seconds less than the token expiration to cache the token.
+   */
+  expirationOffsetSeconds?: number;
+  /**
+   * This is an advanced option that should only be used if you do not want to persist information in ZoneCache.
+   */
+  useMemoryCacheOnly?: boolean;
+}
+
+/* Excluded from this release type: urlForwardHandler */
+
+/* Excluded from this release type: urlRewriteHandler */
+
+declare type UserDataDefault = any;
+
+/* Excluded from this release type: ValidateFunction */
+
+/**
+ * Validates the body of an incoming request based on a JSON schema.
+ *
+ * @remarks
+ * The Validate JSON Schema policy is used to validate the body of incoming
+ * requests. It works using JSON Schemas defined in the `Schemas` folder of your
+ * project.
+ *
+ * When configured, any requests that do not have a body conforming to your JSON
+ * schema will be rejected with a `400: Bad Request` response containing a detailed
+ * error message (in JSON) explaining why the body was not accepted.
+ *
+ * @title JSON Body Validation
+ * @public
+ * @deprecated Use the new {@link https://zuplo.com/docs/policies/request-validation-inbound|Request Validation Policy}.
+ * The new policy validates JSON bodies like this policy, but also supports validation of parameters, query strings, etc.
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare const ValidateJsonSchemaInbound: InboundPolicyHandler<ValidateJsonSchemaInboundInternalOptions>;
+
+/* Excluded from this release type: ValidateJsonSchemaInboundInternalOptions */
+
+/**
+ * The options for this policy.
+ */
+export declare interface ValidateJsonSchemaInboundOptions {
+  /**
+   * The JSON schema to validate against.
+   */
+  validator: string;
+}
+
+/**
+ * The action to perform when validation fails.
+ */
+declare type ValidationOptions =
+  | "none"
+  | "log-only"
+  | "reject-and-log"
+  | "reject-only";
+
+/**
+ * The action to perform when validation fails.
+ */
+declare type ValidationOptions1 =
+  | "none"
+  | "log-only"
+  | "reject-and-log"
+  | "reject-only";
+
+/**
+ * The action to perform when validation fails.
+ */
+declare type ValidationOptions2 =
+  | "none"
+  | "log-only"
+  | "reject-and-log"
+  | "reject-only";
+
+/**
+ * The action to perform when validation fails.
+ */
+declare type ValidationOptions3 =
+  | "none"
+  | "log-only"
+  | "reject-and-log"
+  | "reject-only";
+
+export declare interface VersionData {
+  name: string;
+  pathPrefix: string;
+  info?: OpenAPIV3_1.InfoObject;
+  /**
+   * The project relative path to the OpenAPI spec.
+   */
+  openApiFile?: string;
+  tags?: Omit<OpenAPIV3_1.TagObject, "externalDocs">[];
+  /**
+   * If false, OpenAPI documentation will not be generated for this version. If openApiFile is set this setting is ignored.
+   */
+  excludeFromOpenApi?: boolean;
+  /**
+   * If true, schema validation found in the OpenAPI spec will be enforced on requests/responses.
+   */
+  enforceOpenApi?: boolean;
+}
+
+declare interface VMWareLogInsightLoggingOptions {
+  url: string;
+  /**
+   * An array of string tuples to replace within the text field of a log entry.
+   * @example
+   * ```
+   * [
+   *  ["'", ""],
+   *  ['"', ""],
+   *  ["\\n", ""],
+   *  ["\\", ""],
+   *  ["*", ""],
+   *  ["&", ""],
+   *  [":", "="],
+   * ]
+   * ```
+   */
+  textReplacements?: [string, string][];
+  /**
+   * The unique agent identifier of the logger.
+   */
+  agentId?: string;
+  fields?: Record<string, string | number | boolean>;
+  onMessageSending?: (event: LogInsightLogEntry) => LogInsightLogEntry;
+}
+
+export declare class VMWareLogInsightLoggingPlugin extends LogPlugin {
+  private options;
+  constructor(options: VMWareLogInsightLoggingOptions);
+  /* Excluded from this release type: getTransport */
+}
+
+declare interface WaitUntilFunc {
+  (promise: Promise<any>): void;
+}
+
+/* Excluded from this release type: webSocketHandler */
+
+/* Excluded from this release type: webSocketPipelineHandler */
+
+/**
+ * Parses XML and converts it to JSON. This policy is useful for converting
+ * legacy XML or SOAP APIs into modern REST APIs. It can be useful to add a
+ * custom outbound policy that runs after this policy to further transform the
+ * raw converted content into something more user friendly.
+ *
+ * @title XML to JSON Outbound
+ * @public
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare class XmlToJsonOutboundPolicy extends OutboundPolicy<XmlToJsonPolicyOptions> {
+  private parser;
+  private parseOnStatusCodes;
+  constructor(options: XmlToJsonPolicyOptions, policyName: string);
+  handler(
+    response: Response,
+    request: ZuploRequest,
+    context: ZuploContext
+  ): Promise<Response>;
+}
+
+/**
+ * The options for this policy.
+ */
+export declare interface XmlToJsonPolicyOptions {
+  /**
+   * Remove namespace string from tag and attribute names.
+   */
+  removeNSPrefix?: boolean;
+  /**
+   * Ignore processing instruction tags. i.e. `<?elementnames <fred>, <bert>, <harry> ?>`.
+   */
+  ignoreProcessingInstructions?: boolean;
+  /**
+   * Ignore declarations. i.e. `<?xml version="1.0"?>`.
+   */
+  ignoreDeclarations?: boolean;
+  /**
+   * Ignore tag attributes.
+   */
+  ignoreAttributes?: boolean;
+  /**
+   * At particular point, if you don't want to parse a tag and it's nested tags then you can set their path in stopNodes. You can also set tags which should not be processed irrespective of their path using * as the wildcard.
+   */
+  stopNodes?: string[];
+  /**
+   * The prefix of attribute names in the resulting JS object.
+   */
+  attributeNamePrefix?: string;
+  /**
+   * Text value of a tag is parsed to #text property by default.
+   */
+  textNodeName?: string;
+  /**
+   * Remove surrounding whitespace from tag or attribute value.
+   */
+  trimValues?: boolean;
+  /**
+   * A list of status codes and ranges "200-299, 304" that should the XML parser should run on. If not set, the parser will run on all status codes.
+   */
+  parseOnStatusCodes?: string | number[];
+}
+
+/**
+ * This is a simple wrapper around the data-center HTTP cache
+ * to enable simple objects to be stored by a string key. This is
+ * useful to us and customers and provides a very high-performance
+ * read-through cache that stores data in the same data-center. It is
+ * not replicated.
+ */
+export declare class ZoneCache<T = any> {
+  #private;
+  constructor(name: string, context: ZuploContext);
+  /* Excluded from this release type: __constructor */
+  get(key: string): Promise<T | undefined>;
+  put(key: string, data: T, ttlSeconds: number): Promise<void>;
+  delete(key: string): Promise<void>;
+  deleteFallback(key: string): Promise<void>;
+  logDebug(...messages: unknown[]): void;
+}
+
+/* Excluded from this release type: ZuploContext */
+
+declare interface ZuploEventContext {
+  waitUntil: WaitUntilFunc;
+}
+
+/**
+ * ZuploRequest includes various parsed objects from the
+ * incoming Request. This object inherits from the web
+ * standard {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request}.
+ * @public
+ */
+export declare class ZuploRequest<
+  TOptions extends RequestGeneric = RequestGeneric,
+> extends Request {
+  #private;
+  constructor(input: string | Request, init?: ZuploRequestInit<TOptions>);
+  /**
+   * A dictionary of query-string values
+   *
+   * @example
+   * The url `https://example.com?foo=bar` would return
+   * the following query object:
+   *
+   * ```
+   * const foo = request.query.foo;
+   * ```
+   *
+   * @readonly
+   */
+  get query(): Readonly<ResolveRequestQuery<TOptions["Query"]>>;
+  /**
+   * If you use tokens in your route’s URL, they are
+   * automatically parsed into properties on the params
+   * property of your request.
+   *
+   * @example
+   * The route `/products/:productId/vendors/:vendorId`
+   * would include two params:
+   *
+   * ```
+   * const productId = request.params.productId;
+   * const vendorId = request.params.vendorId;
+   * ```
+   * @readonly
+   */
+  get params(): Readonly<ResolveRequestParams<TOptions["Params"]>>;
+  /**
+   * An optional object identifying a ‘user’.
+   *
+   * @remarks
+   * If undefined this typically means the request is
+   * anonymous. If present, the user object will have
+   * a sub property that is a unique identifier for
+   * that user. There is also an optional data property
+   * that is of any type that typically contains other
+   * information about the user. When using JWT tokens
+   * you’ll usually find all the claims here.
+   *
+   * @readonly
+   */
+  user?: RequestUser<ResolveUserData<TOptions["UserData"]>>;
+}
+
+/**
+ * The initialization values of a request
+ * @public
+ */
+declare interface ZuploRequestInit<
+  TOptions extends RequestInitGeneric = RequestInitGeneric,
+> extends RequestInit {
+  params?: ResolveRequestParams<TOptions["Params"]>;
+  user?: ResolveUserData<TOptions["UserData"]>;
+}
+
+export {};