@zuplo/runtime 5.1966.0 → 5.1968.0

package/types-public.d.ts

@@ -1,5 +1,4 @@
 import { KeyLike } from 'jose';
-import type { OpenAPIV3_1 } from 'openapi-types';
 import type { ValidateFunction as ValidateFunction_2 } from 'ajv';
 
 /**
@@ -390,7 +389,7 @@ declare interface AWSLoggingOptions {
 export declare class AWSLoggingPlugin extends LogPlugin {
     private options;
     constructor(options: AWSLoggingOptions);
-    getTransport(): LogTransport;
+    /* Excluded from this release type: getTransport */
 }
 
 export declare class BackgroundDispatcher<TPayload> {
@@ -904,13 +903,16 @@ declare interface DataDogMetricsOptions {
 export declare class DataDogMetricsPlugin extends MetricsPlugin {
     private options;
     constructor(options: DataDogMetricsOptions);
-    getTransport(): MetricsTransport;
+    /* Excluded from this release type: getTransport */
     static setContext(context: ZuploContext, data: DataDogMetricsContext): void;
 }
 
 /* Excluded from this release type: DevPortalRuntimeConfig */
 
-/* Excluded from this release type: DispatchFunction */
+/**
+ * @public
+ */
+declare type DispatchFunction<TPayload> = (batch: TPayload[]) => Promise<void>;
 
 declare interface DynaTraceLoggingOptions {
     url: string;
@@ -938,7 +940,7 @@ declare interface DynatraceMetricsOptions {
 export declare class DynatraceMetricsPlugin extends MetricsPlugin {
     private options;
     constructor(options: DynatraceMetricsOptions);
-    getTransport(): MetricsTransport;
+    /* Excluded from this release type: getTransport */
     static setContext(context: ZuploContext, data: DynatraceMetricsContext): void;
 }
 
@@ -1286,7 +1288,12 @@ export declare class MemoryZoneReadThroughCache<T = unknown> {
     put(key: string, data: T, ttlSeconds: number): void;
 }
 
-/* Excluded from this release type: MeteringPlugin */
+/**
+ * Base class for determining type of plugin
+ * @public
+ */
+declare abstract class MeteringPlugin extends SystemRuntimePlugin {
+}
 
 /* Excluded from this release type: MeteringRegions */
 
@@ -1294,7 +1301,32 @@ export declare class MemoryZoneReadThroughCache<T = unknown> {
 
 /* Excluded from this release type: MeteringSubscriptionStatus */
 
-/* Excluded from this release type: MetricsData */
+/**
+ * @public
+ */
+declare interface MetricsData {
+    timestamp: Date;
+    durationMs: number;
+    statusCode: number;
+    requestContentLength?: number;
+    responseContentLength?: number;
+    requestId: string;
+    routePath: string;
+    systemRouteName?: string;
+    method: HttpMethod;
+    rayId?: string;
+    instanceId: string;
+    userSub?: string;
+    clientIp?: string;
+    asn?: number;
+    asOrganization?: string;
+    colo?: string;
+    continent?: string;
+    country?: string;
+    city?: string;
+    latitude?: string;
+    longitude?: string;
+}
 
 declare abstract class MetricsPlugin extends RuntimePlugin {
     /* Excluded from this release type: getTransport */
@@ -1508,6 +1540,468 @@ declare interface OnSendingAwsLambdaEventHook {
 
 /* Excluded from this release type: openApiSpecHandler */
 
+declare namespace OpenAPIV3 {
+    interface Document<T extends {} = {}> {
+        openapi: string;
+        info: InfoObject;
+        servers?: ServerObject[];
+        paths: PathsObject<T>;
+        components?: ComponentsObject;
+        security?: SecurityRequirementObject[];
+        tags?: TagObject[];
+        externalDocs?: ExternalDocumentationObject;
+        'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
+        'x-express-openapi-validation-strict'?: boolean;
+    }
+    interface InfoObject {
+        title: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: ContactObject;
+        license?: LicenseObject;
+        version: string;
+    }
+    interface ContactObject {
+        name?: string;
+        url?: string;
+        email?: string;
+    }
+    interface LicenseObject {
+        name: string;
+        url?: string;
+    }
+    interface ServerObject {
+        url: string;
+        description?: string;
+        variables?: {
+            [variable: string]: ServerVariableObject;
+        };
+    }
+    interface ServerVariableObject {
+        enum?: string[];
+        default: string;
+        description?: string;
+    }
+    interface PathsObject<T extends {} = {}, P extends {} = {}> {
+        [pattern: string]: (PathItemObject<T> & P) | undefined;
+    }
+    enum HttpMethods {
+        GET = "get",
+        PUT = "put",
+        POST = "post",
+        DELETE = "delete",
+        OPTIONS = "options",
+        HEAD = "head",
+        PATCH = "patch",
+        TRACE = "trace"
+    }
+    type PathItemObject<T extends {} = {}> = {
+        $ref?: string;
+        summary?: string;
+        description?: string;
+        servers?: ServerObject[];
+        parameters?: (ReferenceObject | ParameterObject)[];
+    } & {
+        [method in HttpMethods]?: OperationObject<T>;
+    };
+    type OperationObject<T extends {} = {}> = {
+        tags?: string[];
+        summary?: string;
+        description?: string;
+        externalDocs?: ExternalDocumentationObject;
+        operationId?: string;
+        parameters?: (ReferenceObject | ParameterObject)[];
+        requestBody?: ReferenceObject | RequestBodyObject;
+        responses: ResponsesObject;
+        callbacks?: {
+            [callback: string]: ReferenceObject | CallbackObject;
+        };
+        deprecated?: boolean;
+        security?: SecurityRequirementObject[];
+        servers?: ServerObject[];
+    } & T;
+    interface ExternalDocumentationObject {
+        description?: string;
+        url: string;
+    }
+    interface ParameterObject extends ParameterBaseObject {
+        name: string;
+        in: string;
+    }
+    interface HeaderObject extends ParameterBaseObject {
+    }
+    interface ParameterBaseObject {
+        description?: string;
+        required?: boolean;
+        deprecated?: boolean;
+        allowEmptyValue?: boolean;
+        style?: string;
+        explode?: boolean;
+        allowReserved?: boolean;
+        schema?: ReferenceObject | SchemaObject;
+        example?: any;
+        examples?: {
+            [media: string]: ReferenceObject | ExampleObject;
+        };
+        content?: {
+            [media: string]: MediaTypeObject;
+        };
+    }
+    type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
+    type ArraySchemaObjectType = 'array';
+    type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+    interface ArraySchemaObject extends BaseSchemaObject {
+        type: ArraySchemaObjectType;
+        items: ReferenceObject | SchemaObject;
+    }
+    interface NonArraySchemaObject extends BaseSchemaObject {
+        type?: NonArraySchemaObjectType;
+    }
+    interface BaseSchemaObject {
+        title?: string;
+        description?: string;
+        format?: string;
+        default?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: boolean;
+        minimum?: number;
+        exclusiveMinimum?: boolean;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        additionalProperties?: boolean | ReferenceObject | SchemaObject;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string[];
+        enum?: any[];
+        properties?: {
+            [name: string]: ReferenceObject | SchemaObject;
+        };
+        allOf?: (ReferenceObject | SchemaObject)[];
+        oneOf?: (ReferenceObject | SchemaObject)[];
+        anyOf?: (ReferenceObject | SchemaObject)[];
+        not?: ReferenceObject | SchemaObject;
+        nullable?: boolean;
+        discriminator?: DiscriminatorObject;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        xml?: XMLObject;
+        externalDocs?: ExternalDocumentationObject;
+        example?: any;
+        deprecated?: boolean;
+    }
+    interface DiscriminatorObject {
+        propertyName: string;
+        mapping?: {
+            [value: string]: string;
+        };
+    }
+    interface XMLObject {
+        name?: string;
+        namespace?: string;
+        prefix?: string;
+        attribute?: boolean;
+        wrapped?: boolean;
+    }
+    interface ReferenceObject {
+        $ref: string;
+    }
+    interface ExampleObject {
+        summary?: string;
+        description?: string;
+        value?: any;
+        externalValue?: string;
+    }
+    interface MediaTypeObject {
+        schema?: ReferenceObject | SchemaObject;
+        example?: any;
+        examples?: {
+            [media: string]: ReferenceObject | ExampleObject;
+        };
+        encoding?: {
+            [media: string]: EncodingObject;
+        };
+    }
+    interface EncodingObject {
+        contentType?: string;
+        headers?: {
+            [header: string]: ReferenceObject | HeaderObject;
+        };
+        style?: string;
+        explode?: boolean;
+        allowReserved?: boolean;
+    }
+    interface RequestBodyObject {
+        description?: string;
+        content: {
+            [media: string]: MediaTypeObject;
+        };
+        required?: boolean;
+    }
+    interface ResponsesObject {
+        [code: string]: ReferenceObject | ResponseObject;
+    }
+    interface ResponseObject {
+        description: string;
+        headers?: {
+            [header: string]: ReferenceObject | HeaderObject;
+        };
+        content?: {
+            [media: string]: MediaTypeObject;
+        };
+        links?: {
+            [link: string]: ReferenceObject | LinkObject;
+        };
+    }
+    interface LinkObject {
+        operationRef?: string;
+        operationId?: string;
+        parameters?: {
+            [parameter: string]: any;
+        };
+        requestBody?: any;
+        description?: string;
+        server?: ServerObject;
+    }
+    interface CallbackObject {
+        [url: string]: PathItemObject;
+    }
+    interface SecurityRequirementObject {
+        [name: string]: string[];
+    }
+    interface ComponentsObject {
+        schemas?: {
+            [key: string]: ReferenceObject | SchemaObject;
+        };
+        responses?: {
+            [key: string]: ReferenceObject | ResponseObject;
+        };
+        parameters?: {
+            [key: string]: ReferenceObject | ParameterObject;
+        };
+        examples?: {
+            [key: string]: ReferenceObject | ExampleObject;
+        };
+        requestBodies?: {
+            [key: string]: ReferenceObject | RequestBodyObject;
+        };
+        headers?: {
+            [key: string]: ReferenceObject | HeaderObject;
+        };
+        securitySchemes?: {
+            [key: string]: ReferenceObject | SecuritySchemeObject;
+        };
+        links?: {
+            [key: string]: ReferenceObject | LinkObject;
+        };
+        callbacks?: {
+            [key: string]: ReferenceObject | CallbackObject;
+        };
+    }
+    type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+    interface HttpSecurityScheme {
+        type: 'http';
+        description?: string;
+        scheme: string;
+        bearerFormat?: string;
+    }
+    interface ApiKeySecurityScheme {
+        type: 'apiKey';
+        description?: string;
+        name: string;
+        in: string;
+    }
+    interface OAuth2SecurityScheme {
+        type: 'oauth2';
+        description?: string;
+        flows: {
+            implicit?: {
+                authorizationUrl: string;
+                refreshUrl?: string;
+                scopes: {
+                    [scope: string]: string;
+                };
+            };
+            password?: {
+                tokenUrl: string;
+                refreshUrl?: string;
+                scopes: {
+                    [scope: string]: string;
+                };
+            };
+            clientCredentials?: {
+                tokenUrl: string;
+                refreshUrl?: string;
+                scopes: {
+                    [scope: string]: string;
+                };
+            };
+            authorizationCode?: {
+                authorizationUrl: string;
+                tokenUrl: string;
+                refreshUrl?: string;
+                scopes: {
+                    [scope: string]: string;
+                };
+            };
+        };
+    }
+    interface OpenIdSecurityScheme {
+        type: 'openIdConnect';
+        description?: string;
+        openIdConnectUrl: string;
+    }
+    interface TagObject {
+        name: string;
+        description?: string;
+        externalDocs?: ExternalDocumentationObject;
+    }
+}
+
+declare namespace OpenAPIV3_1 {
+    type Modify<T, R> = Omit<T, keyof R> & R;
+    type PathsWebhooksComponents<T extends {} = {}> = {
+        paths: PathsObject<T>;
+        webhooks: Record<string, PathItemObject | ReferenceObject>;
+        components: ComponentsObject;
+    };
+    type Document<T extends {} = {}> = Modify<Omit<OpenAPIV3.Document<T>, 'paths' | 'components'>, {
+        info: InfoObject;
+        jsonSchemaDialect?: string;
+        servers?: ServerObject[];
+    } & ((Pick<PathsWebhooksComponents<T>, 'paths'> & Omit<Partial<PathsWebhooksComponents<T>>, 'paths'>) | (Pick<PathsWebhooksComponents<T>, 'webhooks'> & Omit<Partial<PathsWebhooksComponents<T>>, 'webhooks'>) | (Pick<PathsWebhooksComponents<T>, 'components'> & Omit<Partial<PathsWebhooksComponents<T>>, 'components'>))>;
+    type InfoObject = Modify<OpenAPIV3.InfoObject, {
+        summary?: string;
+        license?: LicenseObject;
+    }>;
+    type ContactObject = OpenAPIV3.ContactObject;
+    type LicenseObject = Modify<OpenAPIV3.LicenseObject, {
+        identifier?: string;
+    }>;
+    type ServerObject = Modify<OpenAPIV3.ServerObject, {
+        url: string;
+        description?: string;
+        variables?: Record<string, ServerVariableObject>;
+    }>;
+    type ServerVariableObject = Modify<OpenAPIV3.ServerVariableObject, {
+        enum?: [string, ...string[]];
+    }>;
+    type PathsObject<T extends {} = {}, P extends {} = {}> = Record<string, (PathItemObject<T> & P) | undefined>;
+    type HttpMethods = OpenAPIV3.HttpMethods;
+    type PathItemObject<T extends {} = {}> = Modify<OpenAPIV3.PathItemObject<T>, {
+        servers?: ServerObject[];
+        parameters?: (ReferenceObject | ParameterObject)[];
+    }> & {
+        [method in HttpMethods]?: OperationObject<T>;
+    };
+    type OperationObject<T extends {} = {}> = Modify<OpenAPIV3.OperationObject<T>, {
+        parameters?: (ReferenceObject | ParameterObject)[];
+        requestBody?: ReferenceObject | RequestBodyObject;
+        responses?: ResponsesObject;
+        callbacks?: Record<string, ReferenceObject | CallbackObject>;
+        servers?: ServerObject[];
+    }> & T;
+    type ExternalDocumentationObject = OpenAPIV3.ExternalDocumentationObject;
+    type ParameterObject = OpenAPIV3.ParameterObject;
+    type HeaderObject = OpenAPIV3.HeaderObject;
+    type ParameterBaseObject = OpenAPIV3.ParameterBaseObject;
+    type NonArraySchemaObjectType = OpenAPIV3.NonArraySchemaObjectType | 'null';
+    type ArraySchemaObjectType = OpenAPIV3.ArraySchemaObjectType;
+    /**
+     * There is no way to tell typescript to require items when type is either 'array' or array containing 'array' type
+     * 'items' will be always visible as optional
+     * Casting schema object to ArraySchemaObject or NonArraySchemaObject will work fine
+     */
+    type SchemaObject = ArraySchemaObject | NonArraySchemaObject | MixedSchemaObject;
+    interface ArraySchemaObject extends BaseSchemaObject {
+        type: ArraySchemaObjectType;
+        items: ReferenceObject | SchemaObject;
+    }
+    interface NonArraySchemaObject extends BaseSchemaObject {
+        type?: NonArraySchemaObjectType;
+    }
+    interface MixedSchemaObject extends BaseSchemaObject {
+        type?: (ArraySchemaObjectType | NonArraySchemaObjectType)[];
+        items?: ReferenceObject | SchemaObject;
+    }
+    type BaseSchemaObject = Modify<Omit<OpenAPIV3.BaseSchemaObject, 'nullable'>, {
+        examples?: OpenAPIV3.BaseSchemaObject['example'][];
+        exclusiveMinimum?: boolean | number;
+        exclusiveMaximum?: boolean | number;
+        contentMediaType?: string;
+        $schema?: string;
+        additionalProperties?: boolean | ReferenceObject | SchemaObject;
+        properties?: {
+            [name: string]: ReferenceObject | SchemaObject;
+        };
+        allOf?: (ReferenceObject | SchemaObject)[];
+        oneOf?: (ReferenceObject | SchemaObject)[];
+        anyOf?: (ReferenceObject | SchemaObject)[];
+        not?: ReferenceObject | SchemaObject;
+        discriminator?: DiscriminatorObject;
+        externalDocs?: ExternalDocumentationObject;
+        xml?: XMLObject;
+        const?: any;
+    }>;
+    type DiscriminatorObject = OpenAPIV3.DiscriminatorObject;
+    type XMLObject = OpenAPIV3.XMLObject;
+    type ReferenceObject = Modify<OpenAPIV3.ReferenceObject, {
+        summary?: string;
+        description?: string;
+    }>;
+    type ExampleObject = OpenAPIV3.ExampleObject;
+    type MediaTypeObject = Modify<OpenAPIV3.MediaTypeObject, {
+        schema?: SchemaObject | ReferenceObject;
+        examples?: Record<string, ReferenceObject | ExampleObject>;
+    }>;
+    type EncodingObject = OpenAPIV3.EncodingObject;
+    type RequestBodyObject = Modify<OpenAPIV3.RequestBodyObject, {
+        content: {
+            [media: string]: MediaTypeObject;
+        };
+    }>;
+    type ResponsesObject = Record<string, ReferenceObject | ResponseObject>;
+    type ResponseObject = Modify<OpenAPIV3.ResponseObject, {
+        headers?: {
+            [header: string]: ReferenceObject | HeaderObject;
+        };
+        content?: {
+            [media: string]: MediaTypeObject;
+        };
+        links?: {
+            [link: string]: ReferenceObject | LinkObject;
+        };
+    }>;
+    type LinkObject = Modify<OpenAPIV3.LinkObject, {
+        server?: ServerObject;
+    }>;
+    type CallbackObject = Record<string, PathItemObject | ReferenceObject>;
+    type SecurityRequirementObject = OpenAPIV3.SecurityRequirementObject;
+    type ComponentsObject = Modify<OpenAPIV3.ComponentsObject, {
+        schemas?: Record<string, SchemaObject>;
+        responses?: Record<string, ReferenceObject | ResponseObject>;
+        parameters?: Record<string, ReferenceObject | ParameterObject>;
+        examples?: Record<string, ReferenceObject | ExampleObject>;
+        requestBodies?: Record<string, ReferenceObject | RequestBodyObject>;
+        headers?: Record<string, ReferenceObject | HeaderObject>;
+        securitySchemes?: Record<string, ReferenceObject | SecuritySchemeObject>;
+        links?: Record<string, ReferenceObject | LinkObject>;
+        callbacks?: Record<string, ReferenceObject | CallbackObject>;
+        pathItems?: Record<string, ReferenceObject | PathItemObject>;
+    }>;
+    type SecuritySchemeObject = OpenAPIV3.SecuritySchemeObject;
+    type HttpSecurityScheme = OpenAPIV3.HttpSecurityScheme;
+    type ApiKeySecurityScheme = OpenAPIV3.ApiKeySecurityScheme;
+    type OAuth2SecurityScheme = OpenAPIV3.OAuth2SecurityScheme;
+    type OpenIdSecurityScheme = OpenAPIV3.OpenIdSecurityScheme;
+    type TagObject = OpenAPIV3.TagObject;
+        {};
+}
+
 /**
  * The Open ID JWT Authentication policy allows you to authenticate incoming requests using an Open ID compliant bearer token.
  *
@@ -1617,7 +2111,16 @@ declare interface ParsedRouteData extends Omit<RouteData, "corsPolicies"> {
     corsPolicies: ParsedCorsPolicyConfiguration[];
 }
 
-/* Excluded from this release type: PolicyBase */
+/**
+ * @public
+ * The base class for inbound and outbound policies
+ */
+declare abstract class PolicyBase<TOptions = any> {
+    options: TOptions;
+    policyName: string;
+    policyType: string;
+    /* Excluded from this release type: __constructor */
+}
 
 export declare interface PolicyConfiguration {
     name: string;
@@ -2128,7 +2631,11 @@ export declare interface RuntimeExtensionsFunction {
     (runtime: RuntimeExtensions): Promise<void>;
 }
 
-/* Excluded from this release type: RuntimePlugin */
+/**
+ * @public
+ */
+declare abstract class RuntimePlugin {
+}
 
 /* Excluded from this release type: RuntimeSettings */
 
@@ -2448,11 +2955,24 @@ export declare interface SupabaseJwtInboundPolicyOptions {
 
 /* Excluded from this release type: SystemRouteName */
 
-/* Excluded from this release type: SystemRuntimePlugin */
+/**
+ * Plugins for registering system capabilities
+ * @public
+ */
+declare abstract class SystemRuntimePlugin extends RuntimePlugin {
+    /* Excluded from this release type: initialize */
+    /* Excluded from this release type: registerRoutes */
+}
 
 /* Excluded from this release type: TelemetryInitializationOptions */
 
-/* Excluded from this release type: TelemetryPlugin */
+/**
+ * Base class for determining type of plugin
+ * @public
+ */
+export declare abstract class TelemetryPlugin extends RuntimePlugin {
+    /* Excluded from this release type: instrument */
+}
 
 /**
  * Uses Azure Active Directory to add an Authorization header to the request in order to authenticate requests using Azure identity.
@@ -2821,7 +3341,12 @@ export declare class VMWareLogInsightLoggingPlugin extends LogPlugin {
     /* Excluded from this release type: getTransport */
 }
 
-/* Excluded from this release type: WaitUntilFunc */
+/**
+ * @public
+ */
+declare interface WaitUntilFunc {
+    (promise: Promise<any>): void;
+}
 
 /* Excluded from this release type: webSocketHandler */