/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */
export type paths = Record<string, never>;
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        /** @description Defines a message named Metadata */
        Metadata: {
            description?: string;
            name: string;
            namespace?: string;
            tags?: string[];
            /** @enum {string} */
            type?: "REST" | "SWAGGER" | "SOAP" | "GRAPHQL" | "ODATA";
            version: string;
            labels?: {
                gatewayTypes?: string[];
            } & {
                [key: string]: unknown;
            };
        };
        Reference: {
            /** @description Field 'ref' with JSON name '$ref' accepts the value of either 'ref' or '$ref' from the YAML file.
             *     If both 'ref' and '$ref' are specified, the value of '$ref' takes priority. */
            $ref: string;
        };
        ReferenceList: components["schemas"]["Reference"][];
        Namespace: {
            URI?: string;
            prefix?: string;
        };
        Namespaces: components["schemas"]["Namespace"][];
        Path: {
            /** @description Field 'path' with JSON name '$path' accepts the value of either 'path' or '$path' from the YAML file.
             *     If both 'path' and '$path' are specified, the value of '$path' takes priority. */
            $path: string;
        };
        AWSLambda: {
            /** @enum {string} */
            kind: "InvokeAWSLambda";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Name of the AWS Lambda function */
                functionName?: string;
                /** @description Version of the AWS Lambda function */
                qualifier?: string;
                /** @enum {string} */
                invocationType?: "request-response" | "event";
                region?: string;
                awsAuthType?: {
                    accessSecret?: string;
                    arn?: {
                        aws_assume_role_arn: string;
                    };
                };
                tlsConnectionProfile?: string;
                input?: string;
                output?: string;
                clientConfig?: {
                    socketTimeout?: number;
                    connectionTimeout?: number;
                    requestTimeout?: number;
                    clientExecutionTimeout?: number;
                    clientRetryCount?: number;
                    connectionExpirationTimeout?: number;
                    enableExpectContinue?: boolean;
                    enableGzip?: boolean;
                    enableHostPrefixInjection?: boolean;
                    maxConnectionIdleTime?: number;
                    responseMetadataCacheSize?: number;
                    enableThrottledRetries?: boolean;
                    enableKeepAlive?: boolean;
                    enableResponseMetadataCache?: boolean;
                    signatureAlgorithm?: string;
                    tcpSendBufferSizeHint?: number;
                    tcpReceiveBufferSizeHint?: number;
                };
                extensions?: {
                    "lw-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            clientConfig?: {
                                serverRetryCount?: number;
                            };
                        };
                    };
                    "webm-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            condition?: string;
                            lambdaConfig?: {
                                alias?: string;
                            };
                            clientConfig?: {
                                retryOnErrorCount?: number;
                            };
                            request_processing?: components["schemas"]["InvokeRequestProcessingSchema"];
                            response_processing?: components["schemas"]["InvokeResponseProcessingSchema"];
                            namespaces?: components["schemas"]["Namespaces"];
                        };
                    };
                };
            };
        };
        Api: {
            /** @enum {string} */
            kind: "API";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                "api-spec": components["schemas"]["Path"];
                uriSchemes?: components["schemas"]["Reference"];
                properties?: components["schemas"]["Reference"];
                cors?: components["schemas"]["Reference"];
                scopes?: components["schemas"]["ReferenceList"];
                "policy-sequence": components["schemas"]["ReferenceList"];
            };
        };
        /** @description The CORS related information is captured in the message CORS */
        CORS: {
            /** @enum {string} */
            kind: "CORS";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                rules: {
                    /** @enum {string} */
                    action: "allow" | "deny";
                    /** @description Multiple instances of allowed origins can be given */
                    originList: string[];
                    /** @description Credential can be allowed or not allowed */
                    allowCredentials?: boolean;
                    /** @description Multiple instances allowed methods can be given */
                    allowMethods?: string[];
                    /** @description Multiple instances of allowed headers can be given */
                    allowHeaders?: string[];
                    /** @description Single instance of maximum age can be given */
                    maxAge?: number;
                    exposeHeaders?: {
                        predefined?: boolean;
                        custom?: string;
                        backend?: boolean;
                    };
                }[];
            };
        };
        Quota: {
            apiVersion: string;
            /** @enum {string} */
            kind: "Quota";
            metadata: components["schemas"]["Metadata"];
            spec: {
                maxRequest?: number;
                interval?: string;
                onLimitReach?: string;
                "x-webm-config"?: {
                    notification?: {
                        enabled?: boolean;
                        notifyAfter?: string;
                        message?: string;
                        email?: string[];
                    };
                    alertConfiguration?: {
                        frequency?: string;
                        message?: string;
                    };
                };
            };
        };
        Product: {
            apiVersion: string;
            /** @enum {string} */
            kind: "Product";
            metadata: components["schemas"]["Metadata"];
            spec: {
                info?: {
                    categories?: string[];
                    contact?: {
                        name?: string;
                        email?: string;
                        url?: string;
                    };
                    license?: {
                        name?: string;
                        url?: string;
                    };
                    termsOfService?: string;
                    summary?: string;
                };
                apis?: {
                    $ref?: string;
                }[];
                plans?: {
                    $ref?: string;
                }[];
                "x-portal-config"?: {
                    visibility?: {
                        view?: {
                            type?: string;
                            orgs?: string[];
                            tags?: string[];
                            enabled?: boolean;
                        };
                        subscribe?: {
                            type?: string;
                            orgs?: string[];
                            tags?: string[];
                            enabled?: boolean;
                        };
                    };
                };
            };
        };
        Plan: {
            apiVersion: string;
            /** @enum {string} */
            kind: "Plan";
            metadata: components["schemas"]["Metadata"];
            spec: {
                pricing?: {
                    value?: number;
                    currency?: string;
                };
                isApprovalRequired?: boolean;
                qos?: {
                    withQuota?: ({
                        $ref: string;
                    } | {
                        unlimited: Record<string, never>;
                    })[];
                    withRateLimit?: {
                        maxRequest?: number;
                        interval?: string;
                        /** @enum {string} */
                        alertConfiguration?: "once" | "always";
                        alertMessage?: string;
                        name?: string;
                    }[];
                };
                "x-datapower-config"?: {
                    withAssemblyCountLimit?: {
                        maxRequest?: string;
                        "hard-limit"?: boolean;
                        "cache-only"?: boolean;
                        "is-client"?: boolean;
                        "use-api-name"?: boolean;
                        "use-app-id"?: boolean;
                        "use-client-id"?: boolean;
                        "dynamic-value"?: number;
                        weight?: number;
                        "auto-decrement"?: boolean;
                        name?: string;
                    }[];
                    withAssemblyRateLimit?: {
                        maxRequest?: number;
                        interval?: string;
                        "cache-only"?: boolean;
                        "is-client"?: boolean;
                        "use-api-name"?: boolean;
                        "use-app-id"?: boolean;
                        "use-client-id"?: boolean;
                        "dynamic-value"?: number;
                        weight?: number;
                        name?: string;
                    }[];
                    withAssemblyQuotaLimit?: {
                        maxRequest?: number;
                        interval?: string;
                        "hard-limit"?: boolean;
                        "cache-only"?: boolean;
                        "is-client"?: boolean;
                        "use-api-name"?: boolean;
                        "use-app-id"?: boolean;
                        "use-client-id"?: boolean;
                        "dynamic-value"?: number;
                        weight?: number;
                        name?: string;
                    }[];
                    apis?: {
                        $ref?: string;
                        operations?: {
                            operationId?: string;
                            path: string;
                            method: string;
                            withQuota?: ({
                                unlimited: Record<string, never>;
                            } | {
                                name: string;
                                /** @enum {string} */
                                onLimitReach?: "block" | "allow";
                                maxRequest: number;
                                interval: string;
                            })[];
                        }[];
                    }[];
                };
            };
        };
        /** @description The policy sequence related information is captured in the message policy sequence */
        StagedPolicySequence: {
            apiVersion: string;
            /** @enum {string} */
            kind: "StagedPolicySequence";
            metadata: components["schemas"]["Metadata"];
            spec: {
                transport?: components["schemas"]["ReferenceList"];
                security?: components["schemas"]["ReferenceList"];
                monitoring?: components["schemas"]["ReferenceList"];
                routing?: components["schemas"]["ReferenceList"];
                "req-processing"?: components["schemas"]["ReferenceList"];
                "res-processing"?: components["schemas"]["ReferenceList"];
                "error-handling"?: components["schemas"]["ReferenceList"];
            };
        };
        /** @description The message identifies the scope */
        Scope: {
            /** @enum {string} */
            kind: "Scope";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                "policy-sequence": components["schemas"]["ReferenceList"];
                /** @description Multiple instances of resources can be given */
                resources: {
                    methods: ("get" | "post" | "put" | "delete" | "patch" | "head" | "keep")[];
                    path: string;
                }[];
            };
        };
        /** @description The validate API Specification related information is captured in the message validateAPISpecification. */
        ValidateAPISpecification: {
            /** @enum {string} */
            kind: "ValidateAPISpecification";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @enum {string} */
                input: "request" | "response" | "message";
                validate: {
                    request: {
                        schema?: {
                            validate?: boolean;
                        };
                        query?: boolean;
                        path?: boolean;
                        header?: boolean;
                        cookie?: boolean;
                        contentType?: boolean;
                    };
                } | {
                    response: {
                        schema?: {
                            validate?: boolean;
                        };
                        header?: boolean;
                        contentType?: boolean;
                    };
                } | {
                    openApiSchemaRef: {
                        schemaReference: string;
                        /** @enum {string} */
                        failureStatusCode: "BadRequest" | "InternalServerError";
                        failureStatusMessage?: string;
                    };
                } | {
                    file: {
                        $path: string;
                        /** @enum {string} */
                        failureStatusCode: "BadRequest" | "InternalServerError";
                        failureStatusMessage?: string;
                    };
                };
                extensions?: {
                    "webm-gateway"?: {
                        apiVersion: string;
                        spec: {
                            validate?: {
                                "custom-headers"?: {
                                    condition: string;
                                    schema: {
                                        feature?: {
                                            name: string;
                                            value: boolean;
                                        }[];
                                    };
                                };
                            };
                        };
                    };
                };
            };
        };
        Project: {
            apiVersion: string;
            /** @enum {string} */
            kind: "Project";
            metadata: components["schemas"]["Metadata"];
            spec: {
                api?: components["schemas"]["ReferenceList"];
            };
        };
        UriSchemes: {
            /** @enum {string} */
            kind: "URISchemes";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Multiple instance of protocol can be given */
                uriSchemes: ("http" | "https")[];
            };
        };
        /** @description The Telemetry information is captured */
        Telemetry: {
            /** @enum {string} */
            kind: "Telemetry";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                attributes?: {
                    [key: string]: string;
                };
                verbosity?: {
                    level?: string;
                    onSuccessTrimTo?: string;
                    /** @enum {string} */
                    inboundLevel?: "basic" | "none" | "normal" | "detailed";
                    /** @enum {string} */
                    outboundLevel?: "basic" | "none" | "normal" | "detailed";
                    scope?: {
                        /** @description Field 'ref' with JSON name '$ref' accepts the value of either 'ref' or '$ref' from the YAML file.
                         *     If both 'ref' and '$ref' are specified, the value of '$ref' takes priority. */
                        $ref?: string;
                    };
                }[];
            };
        };
        Properties: {
            /** @enum {string} */
            kind: "Properties";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                values: {
                    [key: string]: string;
                };
            };
        };
        LoadBalancer: {
            /** @enum {string} */
            kind: "LoadBalancer";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                input?: string;
                output?: string;
                roundRobinHttp?: {
                    verb?: string;
                    statusException?: {
                        pattern: string;
                    }[];
                    endpoints?: {
                        suspendTimeout?: number;
                        endpoint: {
                            name?: string;
                            tlsClientProfile?: string;
                            url?: string;
                            urlType?: string;
                            version?: string;
                            timeout?: number;
                            compression?: boolean;
                            chunkedUploads?: boolean;
                            persistentConnection?: boolean;
                        };
                    }[];
                };
                extensions?: {
                    "webm-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            endpoints?: {
                                name?: string;
                                connectionTimeout?: number;
                                sslConfig?: {
                                    keyStoreAlias?: string;
                                    keyAlias?: string;
                                    trustStoreAlias?: string;
                                };
                                serviceRegistryParameters?: {
                                    name?: string;
                                    value?: string;
                                }[];
                            }[];
                        };
                    };
                };
            };
        };
        SetAuthorization: {
            /** @enum {string} */
            kind: "SetAuthorization";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                basic: {
                    static: {
                        username: string;
                        password: string;
                    };
                    /** @enum {string} */
                    valueType?: "plain" | "jsonata";
                } | {
                    useIncoming: Record<string, never>;
                };
                message?: string;
            } | {
                oAuth2: {
                    token: string;
                } | {
                    useIncoming: Record<string, never>;
                };
                message?: string;
            } | {
                ntlm: {
                    static: {
                        username: string;
                        password: string;
                    };
                } | {
                    useIncoming: Record<string, never>;
                } | {
                    transparent: Record<string, never>;
                };
                message?: string;
            } | {
                jwt: {
                    useIncoming: Record<string, never>;
                };
                message?: string;
            } | {
                kerberos: {
                    useIncoming: Record<string, never>;
                } | {
                    delegateIncomingCredentials: {
                        clientPassword: string;
                        clientPrincipal: string;
                        servicePrincipal: string;
                        /** @enum {string} */
                        servicePrincipalNameform: "Username" | "Hostbased";
                    };
                } | {
                    incomingHTTPBasicAuthCred: {
                        servicePrincipal: string;
                        /** @enum {string} */
                        servicePrincipalNameform: "Username" | "Hostbased";
                    };
                } | {
                    useCustomCredentials: {
                        clientPassword: string;
                        clientPrincipal: string;
                        servicePrincipal: string;
                        /** @enum {string} */
                        servicePrincipalNameform: "Username" | "Hostbased";
                    };
                };
                message?: string;
            } | {
                anonymous: Record<string, never>;
                message?: string;
            };
        };
        Invoke: {
            /** @enum {string} */
            kind: "Invoke";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                cache?: {
                    expire?: {
                        fromMessageHeader: {
                            headerName: string;
                            messageName: string;
                        };
                    } | {
                        fromVariable: {
                            name: string;
                        };
                    } | {
                        static: {
                            /** Format: uint64 */
                            seconds: number;
                        };
                    };
                    scope?: {
                        narrowScope: Record<string, never>;
                    } | {
                        wideScope: {
                            scopeId: string;
                        };
                    };
                };
                endpoint: {
                    http: {
                        statusException?: {
                            pattern: string;
                        }[];
                        target: {
                            /** @default true */
                            persistentConnection: boolean;
                            /**
                             * Format: uint64
                             * @default 20
                             */
                            timeout: number;
                            tlsClientProfile?: string;
                            url: string;
                            /** @default false */
                            compression: boolean;
                            /** @default false */
                            chunkedUploads: boolean;
                            /** @enum {string} */
                            urlType?: "plain" | "variables" | "jsonata";
                            /** @enum {string} */
                            version?: "HTTP/1.0" | "HTTP/1.1" | "HTTP/2";
                        };
                        verb?: string;
                    };
                };
                input?: string;
                output?: string;
                extensions?: {
                    "webm-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            endpoint?: {
                                http?: {
                                    target?: {
                                        connectionTimeout?: number;
                                    };
                                    sslConfig?: {
                                        keyStoreAlias?: string;
                                        keyAlias?: string;
                                        trustStoreAlias?: string;
                                    };
                                    serviceRegistryParameters?: {
                                        name?: string;
                                        value?: string;
                                    }[];
                                };
                            };
                        };
                    };
                };
            };
        };
        GlobalPolicy: {
            /** @enum {string} */
            kind: "GlobalPolicy";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                "filter-api-type"?: string[];
                "filter-http-methods"?: ("GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD")[];
                "filter-attributes"?: string;
                "policy-sequence": components["schemas"]["ReferenceList"];
            };
        };
        InboundBulkHead: {
            /** @enum {string} */
            kind: "InboundBulkHead";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                maxConcurrentCalls?: number;
                enableBulkheadForCallbacks?: {
                    maxConcurrentCallbacks?: number;
                };
                retryAfterResponseHeader?: {
                    retryAfterValue?: number;
                };
            };
        };
        SetMediaType: {
            /** @enum {string} */
            kind: "SetMediaType";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                defaultAcceptHeader?: string;
                defaultContentType?: string;
            };
        };
        InboundMessaging: {
            /** @enum {string} */
            kind: "InboundMessaging";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                alias?: string;
                source?: {
                    name?: string;
                    /** @enum {string} */
                    type?: "QUEUE" | "TOPIC";
                    selector?: string[];
                    resource?: string;
                    /** @enum {string} */
                    httpMethod?: "GET" | "POST" | "PUT" | "DELETE";
                    contentType?: string;
                }[];
            };
        };
        IAM: {
            /** @enum {string} */
            kind: "IAM";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                accessControl?: ({
                    httpBasic?: {
                        applicationSecurity?: {
                            /** @enum {string} */
                            mode?: "authorize" | "identify" | "authenticate";
                        };
                        credentialLocation?: {
                            httpHeader?: {
                                name?: string;
                            };
                        };
                        credentialRegistry?: string[];
                        userGroupAuthorization?: {
                            requiredGroups?: string[];
                        };
                    };
                } | {
                    apiKey?: {
                        applicationSecurity?: {
                            /** @enum {string} */
                            mode?: "authorize" | "identify" | "authenticate";
                        };
                        credentialLocation?: {
                            httpHeader?: {
                                name?: string;
                            };
                        };
                    };
                } | {
                    oauth?: {
                        applicationSecurity?: {
                            /** @enum {string} */
                            mode?: "authorize" | "identify" | "authenticate";
                        };
                        credentialLocation?: {
                            httpHeader?: {
                                name?: string;
                            };
                        };
                        providers?: string[];
                        introspectionCredentials?: {
                            idHeader?: string;
                            secretheader?: string;
                        };
                        audClaim?: string[];
                        requiredScopes?: {
                            provider?: string;
                            scopes?: string[];
                        }[];
                    };
                } | {
                    jwt?: {
                        applicationSecurity?: {
                            /** @enum {string} */
                            mode?: "authorize" | "identify" | "authenticate";
                        };
                        credentialLocation?: {
                            httpHeader?: {
                                name?: string;
                            };
                        };
                        providers?: string[];
                        requiredClaims?: {
                            provider?: string;
                            claims?: {
                                name?: string;
                                value?: string;
                            }[];
                        }[];
                    };
                } | {
                    hostname?: {
                        applicationSecurity?: {
                            /** @enum {string} */
                            mode?: "authorize" | "identify" | "authenticate";
                        };
                    };
                } | {
                    ipAddress?: {
                        applicationSecurity?: {
                            /** @enum {string} */
                            mode?: "authorize" | "identify" | "authenticate";
                        };
                    };
                } | {
                    certificate?: {
                        applicationSecurity?: {
                            /** @enum {string} */
                            mode?: "authorize" | "identify" | "authenticate";
                        };
                        credentialLocation?: {
                            httpHeader?: {
                                name?: string;
                            };
                        };
                    };
                } | {
                    payloadElement?: {
                        name?: string;
                    };
                } | {
                    httpHeaders?: {
                        applicationSecurity?: {
                            /** @enum {string} */
                            mode?: "authorize" | "identify" | "authenticate";
                        };
                        credentialLocation?: string[];
                    };
                })[][];
                extensions?: {
                    "lw-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            securityNamespace?: string;
                            accessControl?: {
                                payloadElement?: {
                                    name?: string;
                                    applicationSecurity?: {
                                        /** @enum {string} */
                                        mode?: "authorize" | "identify" | "authenticate";
                                    };
                                    credentialLocation?: {
                                        regex?: string;
                                    } | {
                                        jsonata?: string;
                                    };
                                }[];
                            };
                        };
                    };
                    "webm-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            /** @enum {string} */
                            authenticationMode?: "ANY" | "ALL";
                            allowAnonymous?: Record<string, never>;
                            triggerPolicyViolation?: boolean;
                            accessControl?: {
                                kerberos?: {
                                    applicationSecurity?: {
                                        /** @enum {string} */
                                        mode?: "authorize" | "identify" | "authenticate";
                                    };
                                    servicePrincipleName?: string;
                                    servicePrinciplePassword?: string;
                                };
                                openIdConnect?: {
                                    applicationSecurity?: {
                                        /** @enum {string} */
                                        mode?: "authorize" | "identify" | "authenticate";
                                    };
                                };
                                payloadElement?: {
                                    applicationSecurity?: {
                                        /** @enum {string} */
                                        mode?: "authorize" | "identify" | "authenticate";
                                    };
                                    payLoadIdentifier?: ({
                                        jPath?: string;
                                    } | {
                                        xpath?: string;
                                        namespaces?: {
                                            prefix?: string;
                                            URI?: string;
                                        }[];
                                    } | {
                                        regex?: string;
                                    })[];
                                };
                            };
                        };
                    };
                };
            };
        };
        AuthorizeUser: {
            /** @enum {string} */
            kind: "AuthorizeUser";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                enabled?: boolean;
                users?: string[];
                groups?: string[];
                teams?: string[];
            };
        };
        SetContextVariable: {
            /** @enum {string} */
            kind: "SetContextVariable";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Can be enabled or disabled */
                enabled?: boolean;
                condition?: string;
                namespaces?: components["schemas"]["Namespaces"];
                /** @description Multiple instances of variable can be given */
                variable?: {
                    name?: string;
                    value?: string;
                }[];
            };
        };
        /** @description The Context Variablemrelated information is captured in the message WebMethodsISService. */
        WebMethodsISService: {
            /** @enum {string} */
            kind: "WebMethodsISService";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                enabled?: boolean;
                condition?: string;
                alias?: string;
                /** @description Multiple instances of Service can be given */
                services?: {
                    complyToISSpec?: boolean;
                    name?: string;
                    runAs?: string;
                }[];
            };
        };
        /** @description The Log Invocation related information is captured in the message LogInvocation */
        LogInvocation: {
            /** @enum {string} */
            kind: "Log";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                enabled?: boolean;
                /** @default false */
                logRequestHeaders: boolean;
                /** @default false */
                logResponseHeaders: boolean;
                /** @default false */
                logRequestPayload: boolean;
                /** @default false */
                logResponsePayload: boolean;
                /** @default false */
                compressPayloads: boolean;
                /** @enum {string} */
                logGenerationFrequency?: "always" | "onfailure" | "onsuccess";
                destination?: components["schemas"]["LogInvocationDestinationsList"];
            };
        };
        MonitorTraffic: {
            /** @enum {string} */
            kind: "MonitorTraffic";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                enabled?: boolean;
                /** @description Single instance of condition can be given */
                condition?: string;
                /** @description Multiple instance of application can be given */
                applications?: string[];
                /** @description Field 'alert_configuration' with JSON name 'alert-configuration' accepts the value of either 'alert_configuration' or 'alert-configuration' from the YAML file.
                 *     If both 'alert_configuration' and 'alert-configuration' are specified, the value of 'alert-configuration' takes priority.
                 *     Multiple instances of alert configuration can be given with JSON name "alert-configuration". */
                "alert-configuration"?: {
                    /** @enum {string} */
                    frequency?: "always" | "once";
                    interval?: string;
                    message?: string;
                };
                "notify-on-breach"?: components["schemas"]["DestinationsList"];
            };
        };
        LogInvocationDestinationsList: (("api_gateway" | "dev_portals" | "snmp" | "jdbc" | "centraSite" | "elasticsearch" | "auditLog" | "apic") | {
            email?: string[];
        } | {
            "log-file"?: {
                /** @enum {string} */
                level?: "info" | "debug" | "warn" | "error";
            };
        })[];
        DestinationsList: (("api_gateway" | "dev_portals" | "snmp" | "jdbc" | "centraSite" | "elasticsearch" | "auditLog" | "apic") | {
            email?: string[];
        } | {
            "log-file"?: {
                /** @enum {string} */
                level?: "info" | "debug" | "warn" | "error";
            };
        })[];
        /** @description The Service Result Cache related information is captured in the message ServiceResultCache */
        ServiceResultCache: {
            /** @enum {string} */
            kind: "CacheServiceResult";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Single instance of condition can be given */
                condition?: string;
                /** @description Can be enabled or disabled */
                enabled?: boolean;
                /** @description single instance pf maximum size can be given */
                maxSize?: string;
                /** @description Single instance of ttl can be given */
                ttl?: string;
            };
        };
        OutboundAlias: {
            /** @enum {string} */
            kind: "OutboundAlias";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                alias: string;
            };
        };
        OutboundAnonymous: {
            /** @enum {string} */
            kind: "OutboundAnonymous";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                [key: string]: unknown;
            };
        };
        XslSchema: {
            $path?: string;
            content?: string;
            feature?: {
                name?: string;
                value?: string;
            }[];
        }[];
        /** @description Single instance of transformation can be given */
        RequestTransformationsSchema: {
            set?: {
                key?: string;
                value?: string;
            }[];
            remove?: string[];
            setPayload?: {
                "content-types"?: {
                    [key: string]: string;
                }[];
                defaultContentType?: string;
                xsl?: components["schemas"]["XslSchema"];
            };
        };
        ResponseTransformationsSchema: {
            abortAPIExecutionForFailure?: boolean;
            copyEntireResponse?: boolean;
            set?: {
                key?: string;
                value?: string;
            }[];
        };
        /** @description Field 'request_processing' with JSON name 'request-processing' accepts the value of either 'request_processing' or 'request-processing' from the YAML file.
         *     If both 'request_processing' and 'request-processing' are specified, the value of 'request-processing' takes priority.
         *     Single instances of request processing can be given with JSON name "request-processing". */
        InvokeRequestProcessingSchema: {
            transformations: components["schemas"]["RequestTransformationsSchema"];
            useIncomingHeaders?: boolean;
        };
        /** @description Field 'response_processing' with JSON name 'response-processing' accepts the value of either 'response_processing' or 'response-processing' from the YAML file.
         *     If both 'response_processing' and 'response-processing' are specified, the value of 'response-processing' takes priority.
         *     Single instances of response processing can be given with JSON name "response-processing". */
        InvokeResponseProcessingSchema: {
            transformations: components["schemas"]["ResponseTransformationsSchema"];
        };
        /** @description The HTTP Invoke related information is captured in the message HTTPInvoke */
        HTTPInvoke: {
            /** @enum {string} */
            kind: "HTTPInvoke";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Can be enabled or disabled */
                enabled?: boolean;
                condition?: string;
                endpoint?: components["schemas"]["Reference"];
                namespaces?: components["schemas"]["Namespaces"];
                request_processing?: components["schemas"]["InvokeRequestProcessingSchema"];
                response_processing?: components["schemas"]["InvokeResponseProcessingSchema"];
            };
        };
        /** @description The Messaging Extension related information is captured in the message MessagingExtension. */
        InvokeMessagingExtension: {
            /** @enum {string} */
            kind: "InvokeMessagingExtension";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Can be enabled or disabled */
                enabled?: boolean;
                /** @description Single instance of conidition can be given */
                condition?: string;
                messageConfig?: components["schemas"]["Reference"];
                namespaces?: components["schemas"]["Namespaces"];
                request_processing?: components["schemas"]["InvokeRequestProcessingSchema"];
                response_processing?: components["schemas"]["InvokeResponseProcessingSchema"];
            };
        };
        /** @description The Data Masking related information is captured in the message Data masking */
        DataMasking: {
            /** @enum {string} */
            kind: "DataMasking";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Apply for pay load can be enabled or disabled */
                applyForPayload?: boolean;
                /** @description Apply for transaction logging can be enabled or disabled */
                applyForTransactionLogging?: boolean;
                /** @description Can be enabled or disabled */
                enabled?: boolean;
                /** @description Multiple instance of match applications can be given */
                matchApplications?: string[];
                /** @description single instance of transformation can be given */
                transformations?: {
                    remove?: {
                        jpath?: string;
                        regex?: string;
                        xpath?: string;
                    }[];
                    setMask?: {
                        jPath?: string;
                        maskValue?: string;
                        namespaces?: components["schemas"]["Namespaces"];
                        regex?: string;
                        xPath?: string;
                    }[];
                };
            };
        };
        ReqeuestProcessingTransformationsSchema: components["schemas"]["RequestTransformationsSchema"] & {
            namespaces?: components["schemas"]["Namespaces"];
            setMethod?: string;
            webMethodsISService?: components["schemas"]["ReferenceList"];
        };
        /** @description The Request Processing related information is captured in the message RequestProcessing */
        RequestProcessing: {
            /** @enum {string} */
            kind: "TransformRequest";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Can be enabled or disabled */
                enabled?: boolean;
                /** @description Single instance of condition can be given */
                condition?: string;
                transformations?: components["schemas"]["ReqeuestProcessingTransformationsSchema"];
            };
        };
        ResponseProcessingTransformationsSchema: components["schemas"]["RequestTransformationsSchema"] & {
            namespaces?: components["schemas"]["Namespaces"];
            setStatus?: {
                code?: string;
                message?: string;
            };
            webMethodsISService?: components["schemas"]["ReferenceList"];
        };
        /** @description The Response Processing related information is captured in the message RequestProcessing */
        ResponseProcessing: {
            /** @enum {string} */
            kind: "TransformResponse";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Can be enabled or disabled */
                enabled?: boolean;
                /** @description Single instance of condition can be given */
                condition?: string;
                transformations?: components["schemas"]["ResponseProcessingTransformationsSchema"];
            };
        };
        Route: {
            /** @enum {string} */
            kind: "Route";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                "default-endpoint"?: components["schemas"]["Reference"];
                "conditional-endpoints"?: {
                    condition?: string;
                    endpoint?: components["schemas"]["Reference"];
                }[];
            } | {
                "default-endpoint"?: components["schemas"]["Reference"];
                "content-based-endpoints"?: {
                    payloadIdentifier?: {
                        jPath?: string;
                    } | {
                        xpath?: string;
                        namespaces?: {
                            prefix?: string;
                            URI?: string;
                        }[];
                    } | {
                        regex?: string;
                    };
                    endpoint?: components["schemas"]["Reference"];
                }[];
            } | {
                "default-endpoint"?: components["schemas"]["Reference"];
                "dynamic-endpoints"?: {
                    useHeader?: {
                        name?: string;
                        $ref?: string;
                    };
                    useContext?: components["schemas"]["Reference"];
                };
            } | {
                "mock-endpoint"?: {
                    enabled?: boolean;
                    $ref?: string;
                };
            } | {
                messageConfig?: components["schemas"]["Reference"];
            };
        };
        /** @description The MessageConfig related information is captured in the message MessageConfig. */
        MessageConfig: {
            /** @enum {string} */
            kind: "MessageConfig";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                connectionAlias?: string;
                destination?: {
                    name?: string;
                    /** @enum {string} */
                    type?: "queue" | "topic";
                };
                replyTo?: {
                    name?: string;
                    /** @enum {string} */
                    type?: "queue" | "topic";
                };
                ttl?: string;
                timeToWait?: string;
                /** @enum {string} */
                deliveryMode?: "persistent" | "non_persistent";
                property?: {
                    key?: string;
                    value?: string;
                }[];
            };
        };
        HTTPEndpoint: {
            /** @enum {string} */
            kind: "HTTPEndpoint";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                url?: string;
                method?: string;
                connectTimeout?: number;
                readTimeout?: number;
                serviceRegistryParameters?: {
                    name?: string;
                    value?: string;
                }[];
                sslConfig?: {
                    keyAlias?: string;
                    keyStoreAlias?: string;
                    trustStoreAlias?: string;
                };
            };
        };
        MockEndpoint: {
            /** @enum {string} */
            kind: "MockEndpoint";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                paths?: {
                    [key: string]: {
                        get?: components["schemas"]["MockEndpointMethodResponse"];
                        post?: components["schemas"]["MockEndpointMethodResponse"];
                        put?: components["schemas"]["MockEndpointMethodResponse"];
                        patch?: components["schemas"]["MockEndpointMethodResponse"];
                        delete?: components["schemas"]["MockEndpointMethodResponse"];
                        head?: components["schemas"]["MockEndpointMethodResponse"];
                        options?: components["schemas"]["MockEndpointMethodResponse"];
                        trace?: components["schemas"]["MockEndpointMethodResponse"];
                    };
                };
            };
        };
        MockEndpointMethodResponse: {
            defaultResponse?: {
                [key: string]: components["schemas"]["MockEndpointResponse"];
            };
            conditionalResponse?: components["schemas"]["MockEndpointConditionalResponse"][];
        };
        MockEndpointResponse: {
            response?: components["schemas"]["Reference"];
        };
        MockEndpointConditionalResponse: {
            condition?: string;
            statusCode?: number;
            response?: components["schemas"]["Reference"];
        };
        MockResponse: {
            /** @enum {string} */
            kind: "MockResponse";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                code?: number;
                data?: {
                    content?: string;
                    contentType?: string;
                }[];
                headers?: {
                    key?: string;
                    value?: string;
                }[];
            };
        };
        /** @description Single instance of transformation can be given */
        ErrorProcessingTransformationsSchema: {
            set?: {
                key?: string;
                value?: string;
            }[];
            remove?: string[];
            setPayload?: {
                "content-types"?: {
                    [key: string]: string;
                }[];
                defaultContentType?: string;
                xsl?: components["schemas"]["XslSchema"];
            };
            namespaces?: components["schemas"]["Namespaces"];
            sendNativeError?: boolean;
        };
        /** @description The Conditional Error Handling related information is captured in the message ConditionalErrorProcessing. */
        ErrorProcessing: {
            /** @enum {string} */
            kind: "ErrorProcessing";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                /** @description Can be enabled or disabled */
                enabled?: boolean;
                /** @description Single instance of condition can be given */
                condition?: string;
                /** @description Field 'pre_processing' with JSON name 'pre-processing' accepts the value of either 'pre_processing' or 'pre-processing' from the YAML file.
                 *     If both 'pre_processing' and 'pre-processing' are specified, the value of 'pre-processing' takes priority.
                 *     Multiple instances of pre processing can be given with JSON name "pre-processing". */
                "pre-processing"?: {
                    webMethodsISService?: components["schemas"]["ReferenceList"];
                    xsl?: components["schemas"]["XslSchema"];
                };
                transformations?: components["schemas"]["ErrorProcessingTransformationsSchema"];
                /** @description Field 'post_processing' with JSON name 'post-processing' accepts the value of either 'post_processing' or 'post-processing' from the YAML file.
                 *     If both 'post_processing' and 'post-processing' are specified, the value of 'post-processing' takes priority.
                 *     Multiple instances of post processing can be given with JSON name 'post-processing". */
                "post-processing"?: {
                    webMethodsISService?: components["schemas"]["ReferenceList"];
                    xsl?: components["schemas"]["XslSchema"];
                };
            };
        };
        /** @description The Throttling Policy related information is captured in the message ThrottlingPolicy */
        Sets: {
            /** @enum {string} */
            kind: "Set";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                messageHeader: {
                    /** @enum {string} */
                    action: "set" | "add" | "combine";
                    headerName: string;
                    value: string;
                    messageName: string;
                };
                /** @enum {string} */
                valueType?: "webm-var-expression" | "plain" | "variables";
            } | {
                messageBody: {
                    messageName: string;
                    value: string;
                };
                /** @enum {string} */
                valueType?: "plain" | "variables" | "jsonata";
            } | {
                messageMethod: {
                    messageName: string;
                    method: string;
                };
                /** @enum {string} */
                valueType?: "plain" | "variables";
            } | {
                messageUri: {
                    messageName: string;
                    /** @enum {string} */
                    nameType: "plain" | "variables" | "jsonata";
                    path: string;
                    queryParams: {
                        name: string;
                        value: string;
                    }[];
                };
                /** @enum {string} */
                valueType?: "plain" | "variables" | "jsonata";
            } | {
                variable: {
                    name: string;
                    value: string;
                };
                /** @enum {string} */
                valueType?: "plain" | "variables" | "jsonata";
            } | {
                distributedVariable: {
                    expire: number;
                    name: string;
                    setExclusive: boolean;
                    value: string;
                };
                /** @enum {string} */
                valueType?: "plain" | "variables" | "jsonata";
            };
        };
        RateLimitDefinition: {
            /** @enum {string} */
            kind: "RateLimitDef";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                consumerSpecific?: boolean;
                dynamicValue?: string;
                max?: number;
                intervalLen?: number;
                /** @enum {string} */
                intervalUnit?: "second" | "minute" | "hour" | "day" | "week" | "calendarweek" | "calendarmonth";
                extensions?: {
                    "lw-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            weightExpr?: string;
                            dynamicValue?: string;
                            exceedAction?: string;
                        };
                    };
                    "wm-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            alertMessage?: string;
                            /** @enum {string} */
                            alertFrequency?: "once" | "always";
                        };
                    };
                };
            };
        };
        /** @description The Throttling Policy related information is captured in the message ThrottlingPolicy */
        RateLimit: {
            /** @enum {string} */
            kind: "RateLimit";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                target?: string | {
                    specified: string[];
                };
                limits?: {
                    limitDef: {
                        name: string;
                        definition: components["schemas"]["Reference"];
                    };
                }[];
                extensions?: {
                    "webm-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            destination: components["schemas"]["DestinationsList"];
                        };
                    };
                    "lwgw-gateway"?: {
                        apiVersion?: string;
                        spec?: {
                            limits?: ({
                                globalLimit: {
                                    name: string;
                                    operation: string;
                                };
                            } | {
                                planLimit: {
                                    name: string;
                                    operation: string;
                                };
                            })[];
                        };
                    };
                };
            };
        };
        Redact: {
            /** @enum {string} */
            kind: "Redact";
            /** @default api.ibm.com/v1 */
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                message: {
                    messageName: string;
                    queryParameters?: string[];
                    headers?: string[];
                    body?: {
                        captures: {
                            jsonata: string[];
                        } | {
                            regex: string[];
                        };
                    };
                };
            } | {
                variable: {
                    name: string;
                    captures: {
                        jsonata: string[];
                    } | {
                        regex: string[];
                    };
                };
            } | {
                distributedVariable: {
                    name: string;
                    captures: {
                        jsonata: string[];
                    } | {
                        regex: string[];
                    };
                };
            };
        };
        Remove: {
            /** @enum {string} */
            kind: "Redact";
            /** @default api.ibm.com/v1 */
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                message: {
                    messageName: string;
                    queryParameters?: string[];
                    headers?: string[];
                    body?: {
                        captures: {
                            jsonata: string[];
                        } | {
                            regex: string[];
                        };
                    };
                };
            } | {
                variable: {
                    name: string;
                    captures: {
                        jsonata: string[];
                    } | {
                        regex: string[];
                    };
                };
            } | {
                distributedVariable: {
                    name: string;
                    captures: {
                        jsonata: string[];
                    } | {
                        regex: string[];
                    };
                };
            };
        };
        Transform: {
            /** @enum {string} */
            kind: "Transform";
            apiVersion: string;
            metadata: components["schemas"]["Metadata"];
            spec: {
                message: {
                    messageName: string;
                    uri?: {
                        jsonataTransformers?: string[];
                        regexTransformers?: {
                            pattern: string;
                            replace: string;
                        }[];
                    };
                    headers?: {
                        headerNames?: string[];
                        jsonataTransformers?: string[];
                        regexTransformers?: {
                            pattern: string;
                            replace: string;
                        }[];
                    };
                    body?: {
                        jsonataTransformers?: {
                            capture?: string;
                            transform?: string;
                        }[];
                        regexTransformers?: {
                            pattern: string;
                            replace: string;
                        }[];
                    };
                };
            } | {
                variable: {
                    name: string;
                    jsonataTransformers?: {
                        capture?: string;
                        transform?: string;
                    }[];
                    regexTransformers?: {
                        pattern: string;
                        replace: string;
                    }[];
                };
            } | {
                distributedVariable: {
                    name: string;
                    jsonataTransformers?: {
                        capture?: string;
                        transform?: string;
                    }[];
                    regexTransformers?: {
                        pattern: string;
                        replace: string;
                    }[];
                };
            };
        };
        DataPowerAssembly: {
            /** @enum {string} */
            kind: "DataPowerAssembly";
            /** @default api.ibm.com/v1 */
            apiVersion: string;
            /** @description Defines a message named Metadata */
            metadata: {
                description?: string;
                name: string;
                namespace?: string;
                tags?: string[];
                /** @enum {string} */
                type?: "REST" | "SWAGGER" | "SOAP" | "GRAPHQL" | "ODATA";
                version: string;
                labels?: {
                    gatewayTypes?: string[];
                };
            };
            spec: {
                "x-ibm-configuration"?: {
                    [key: string]: unknown;
                };
            };
        };
        /**
         * @description Defines an enumeration named KindEnums. This enum defines the unique kind name which identifies assets
         * @enum {string}
         */
        KindEnums: "API" | "Scope" | "Project" | "StagedPolicySequence" | "InvokeAWSLambda" | "ValidateAPISpecification" | "CORS" | "Quota" | "Plan" | "Product" | "URISchemes" | "properties" | "Telemetry" | "Properties" | "LoadBalancer" | "SetAuthorization" | "Invoke" | "GlobalPolicy" | "InboundBulkHead" | "SetMediaType" | "InboundMessaging" | "IAM" | "AuthorizeUser" | "SetContextVariable" | "WebMethodsISService" | "Log" | "MonitorTraffic" | "CacheServiceResult" | "OutboundAlias" | "OutboundAnonymous" | "HTTPInvoke" | "InvokeMessagingExtension" | "DataMasking" | "TransformRequest" | "TransformResponse" | "Route" | "MessageConfig" | "HTTPEndpoint" | "MockEndpoint" | "MockResponse" | "ErrorProcessing" | "Set" | "RateLimitDef" | "RateLimit" | "Redact" | "Remove" | "Transform" | "DataPowerAssembly";
    };
    responses: never;
    parameters: never;
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, never>;
export type operations = Record<string, never>;
//# sourceMappingURL=api-model-kinds_new.d.ts.map