// This is an automatically generated code sample.
// To make this code sample work in your Oracle Cloud tenancy,
// please replace the values for any parameters whose current values do not fit
// your use case (such as resource IDs, strings containing ‘EXAMPLE’ or ‘unique_id’, and
// boolean, number, and enum parameters with values not fitting your use case).

import * as apigateway from "oci-apigateway";
import common = require("oci-common");

// Create a default authentication provider that uses the DEFAULT
// profile in the configuration file.
// Refer to <see href="https://docs.cloud.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm#SDK_and_CLI_Configuration_File>the public documentation</see> on how to prepare a configuration file.

const provider: common.ConfigFileAuthenticationDetailsProvider = new common.ConfigFileAuthenticationDetailsProvider();

(async () => {
  try {
    // Create a service client
    const client = new apigateway.DeploymentClient({ authenticationDetailsProvider: provider });

    // Create a request and dependent object(s).
    const createDeploymentDetails = {
      displayName: "EXAMPLE-displayName-Value",
      gatewayId: "ocid1.test.oc1..<unique_ID>EXAMPLE-gatewayId-Value",
      compartmentId: "ocid1.test.oc1..<unique_ID>EXAMPLE-compartmentId-Value",
      pathPrefix: "EXAMPLE-pathPrefix-Value",
      specification: {
        requestPolicies: {
          authentication: {
            type: "CUSTOM_AUTHENTICATION",
            functionId: "ocid1.test.oc1..<unique_ID>EXAMPLE-functionId-Value",
            tokenHeader: "EXAMPLE-tokenHeader-Value",
            tokenQueryParam: "EXAMPLE-tokenQueryParam-Value",
            parameters: {
              EXAMPLE_KEY_vViVC: "EXAMPLE_VALUE_zl3jRdiITvSAH2qmRw6C"
            },
            cacheKey: ["EXAMPLE--Value"],
            validationFailurePolicy: {
              type: "MODIFY_RESPONSE",
              responseCode: "EXAMPLE-responseCode-Value",
              responseMessage: "EXAMPLE-responseMessage-Value",
              responseHeaderTransformations: {
                setHeaders: {
                  items: [
                    {
                      name: "EXAMPLE-name-Value",
                      values: ["EXAMPLE--Value"],
                      ifExists: apigateway.models.SetHeaderPolicyItem.IfExists.Append
                    }
                  ]
                },
                renameHeaders: {
                  items: [
                    {
                      from: "EXAMPLE-from-Value",
                      to: "EXAMPLE-to-Value"
                    }
                  ]
                },
                filterHeaders: {
                  type: apigateway.models.FilterHeaderPolicy.Type.Allow,
                  items: [
                    {
                      name: "EXAMPLE-name-Value"
                    }
                  ]
                }
              }
            },
            isAnonymousAccessAllowed: true
          },
          rateLimiting: {
            rateInRequestsPerSecond: 146,
            rateKey: apigateway.models.RateLimitingPolicy.RateKey.ClientIp
          },
          cors: {
            allowedOrigins: ["EXAMPLE--Value"],
            allowedMethods: ["EXAMPLE--Value"],
            allowedHeaders: ["EXAMPLE--Value"],
            exposedHeaders: ["EXAMPLE--Value"],
            isAllowCredentialsEnabled: true,
            maxAgeInSeconds: 631
          },
          mutualTls: {
            isVerifiedCertificateRequired: false,
            allowedSans: ["EXAMPLE--Value"]
          },
          usagePlans: {
            tokenLocations: ["EXAMPLE--Value"]
          },
          dynamicAuthentication: {
            selectionSource: {
              type: "SINGLE",
              selector: "EXAMPLE-selector-Value"
            },
            authenticationServers: [
              {
                key: {
                  type: "WILDCARD",
                  expression: "EXAMPLE-expression-Value",
                  isDefault: false,
                  name: "EXAMPLE-name-Value"
                },
                authenticationServerDetail: {
                  type: "JWT_AUTHENTICATION",
                  tokenHeader: "EXAMPLE-tokenHeader-Value",
                  tokenQueryParam: "EXAMPLE-tokenQueryParam-Value",
                  tokenAuthScheme: "EXAMPLE-tokenAuthScheme-Value",
                  maxClockSkewInSeconds: 111.89045,
                  issuers: ["EXAMPLE--Value"],
                  audiences: ["EXAMPLE--Value"],
                  verifyClaims: [
                    {
                      key: "EXAMPLE-key-Value",
                      values: ["EXAMPLE--Value"],
                      isRequired: true
                    }
                  ],
                  publicKeys: {
                    type: "REMOTE_JWKS",
                    uri: "EXAMPLE-uri-Value",
                    isSslVerifyDisabled: false,
                    maxCacheDurationInHours: 15
                  },
                  isAnonymousAccessAllowed: false
                }
              }
            ]
          }
        },
        loggingPolicies: {
          accessLog: {
            isEnabled: true
          },
          executionLog: {
            isEnabled: false,
            logLevel: apigateway.models.ExecutionLogPolicy.LogLevel.Warn
          }
        },
        routes: [
          {
            path: "EXAMPLE-path-Value",
            methods: [apigateway.models.ApiSpecificationRoute.Methods.Any],
            requestPolicies: {
              authorization: {
                type: "ANY_OF",
                allowedScope: ["EXAMPLE--Value"]
              },
              cors: {
                allowedOrigins: ["EXAMPLE--Value"],
                allowedMethods: ["EXAMPLE--Value"],
                allowedHeaders: ["EXAMPLE--Value"],
                exposedHeaders: ["EXAMPLE--Value"],
                isAllowCredentialsEnabled: true,
                maxAgeInSeconds: 114
              },
              queryParameterValidations: {
                parameters: [
                  {
                    required: false,
                    name: "EXAMPLE-name-Value"
                  }
                ],
                validationMode:
                  apigateway.models.QueryParameterValidationRequestPolicy.ValidationMode.Enforcing
              },
              headerValidations: {
                headers: [
                  {
                    required: false,
                    name: "EXAMPLE-name-Value"
                  }
                ],
                validationMode:
                  apigateway.models.HeaderValidationRequestPolicy.ValidationMode.Disabled
              },
              bodyValidation: {
                required: false,
                content: {
                  EXAMPLE_KEY_wRPpL: {
                    validationType: "NONE"
                  }
                },
                validationMode:
                  apigateway.models.BodyValidationRequestPolicy.ValidationMode.Disabled
              },
              headerTransformations: {
                setHeaders: {
                  items: [
                    {
                      name: "EXAMPLE-name-Value",
                      values: ["EXAMPLE--Value"],
                      ifExists: apigateway.models.SetHeaderPolicyItem.IfExists.Append
                    }
                  ]
                },
                renameHeaders: {
                  items: [
                    {
                      from: "EXAMPLE-from-Value",
                      to: "EXAMPLE-to-Value"
                    }
                  ]
                },
                filterHeaders: {
                  type: apigateway.models.FilterHeaderPolicy.Type.Allow,
                  items: [
                    {
                      name: "EXAMPLE-name-Value"
                    }
                  ]
                }
              },
              queryParameterTransformations: {
                setQueryParameters: {
                  items: [
                    {
                      name: "EXAMPLE-name-Value",
                      values: ["EXAMPLE--Value"],
                      ifExists: apigateway.models.SetQueryParameterPolicyItem.IfExists.Skip
                    }
                  ]
                },
                renameQueryParameters: {
                  items: [
                    {
                      from: "EXAMPLE-from-Value",
                      to: "EXAMPLE-to-Value"
                    }
                  ]
                },
                filterQueryParameters: {
                  type: apigateway.models.FilterQueryParameterPolicy.Type.Block,
                  items: [
                    {
                      name: "EXAMPLE-name-Value"
                    }
                  ]
                }
              },
              responseCacheLookup: {
                type: "SIMPLE_LOOKUP_POLICY",
                cacheKeyAdditions: ["EXAMPLE--Value"],
                isEnabled: true,
                isPrivateCachingEnabled: true
              }
            },
            responsePolicies: {
              headerTransformations: {
                setHeaders: {
                  items: [
                    {
                      name: "EXAMPLE-name-Value",
                      values: ["EXAMPLE--Value"],
                      ifExists: apigateway.models.SetHeaderPolicyItem.IfExists.Overwrite
                    }
                  ]
                },
                renameHeaders: {
                  items: [
                    {
                      from: "EXAMPLE-from-Value",
                      to: "EXAMPLE-to-Value"
                    }
                  ]
                },
                filterHeaders: {
                  type: apigateway.models.FilterHeaderPolicy.Type.Allow,
                  items: [
                    {
                      name: "EXAMPLE-name-Value"
                    }
                  ]
                }
              },
              responseCacheStore: {
                type: "FIXED_TTL_STORE_POLICY",
                timeToLiveInSeconds: 694
              }
            },
            loggingPolicies: {
              accessLog: {
                isEnabled: false
              },
              executionLog: {
                isEnabled: false,
                logLevel: apigateway.models.ExecutionLogPolicy.LogLevel.Info
              }
            },
            backend: {
              type: "STOCK_RESPONSE_BACKEND",
              body: "EXAMPLE-body-Value",
              status: 487,
              headers: [
                {
                  name: "EXAMPLE-name-Value",
                  value: "EXAMPLE-value-Value"
                }
              ]
            }
          }
        ]
      },
      freeformTags: {
        EXAMPLE_KEY_ygcQ8: "EXAMPLE_VALUE_VzIb2AFl2MXpmxS9lRU7"
      },
      definedTags: {
        EXAMPLE_KEY_GwCrr: {
          EXAMPLE_KEY_Bblp7: "EXAMPLE--Value"
        }
      }
    };

    const createDeploymentRequest: apigateway.requests.CreateDeploymentRequest = {
      createDeploymentDetails: createDeploymentDetails,
      opcRetryToken: "EXAMPLE-opcRetryToken-Value",
      opcRequestId: "4SWXHLJHRAI7LRJJZCSW<unique_ID>"
    };

    // Send request to the Client.
    const createDeploymentResponse = await client.createDeployment(createDeploymentRequest);
  } catch (error) {
    console.log("createDeployment Failed with error  " + error);
  }
})();