export interface CreateFunctionRequest {
  __type?: "CreateFunctionRequest";
  /**
   *
For network connectivity to AWS resources in a VPC, specify a list of security groups and subnets in the VPC.
   *       When you connect a function to a VPC, it can only access resources and the internet through that VPC. For more
   *       information, see VPC Settings.

   */
  VpcConfig?: VpcConfig;

  /**
   *
A description of the function.

   */
  Description?: string;

  /**
   *
The amount of memory that your function has access to. Increasing the function's memory also increases its CPU
   *       allocation. The default value is 128 MB. The value must be a multiple of 64 MB.

   */
  MemorySize?: number;

  /**
   *
The ARN of the AWS Key Management Service (AWS KMS) key that's used to encrypt your function's environment
   *       variables. If it's not provided, AWS Lambda uses a default service key.

   */
  KMSKeyArn?: string;

  /**
   *
A list of function layers
   *       to add to the function's execution environment. Specify each layer by its ARN, including the version.

   */
  Layers?: string[];

  /**
   *
Set to true to publish the first version of the function during creation.

   */
  Publish?: boolean;

  /**
   *
Set Mode to Active to sample and trace a subset of incoming requests with AWS
   *       X-Ray.

   */
  TracingConfig?: TracingConfig;

  /**
   *
The name of the method within your code that Lambda calls to execute your function. The format includes the
   *       file name. It can also include namespaces and other qualifiers, depending on the runtime. For more information,
   *       see Programming Model.

   */
  Handler: string | undefined;

  /**
   *
The amount of time that Lambda allows a function to run before stopping it. The default is 3 seconds. The
   *       maximum allowed value is 900 seconds.

   */
  Timeout?: number;

  /**
   *
The code for the function.

   */
  Code: FunctionCode | undefined;

  /**
   *
The identifier of the function's runtime.

   */
  Runtime: Runtime | string | undefined;

  /**
   *
Connection settings for an Amazon EFS file system.

   */
  FileSystemConfigs?: FileSystemConfig[];

  /**
   *
The Amazon Resource Name (ARN) of the function's execution role.

   */
  Role: string | undefined;

  /**
   *
Environment variables that are accessible from function code during execution.

   */
  Environment?: Environment;

  /**
   *
A list of tags to apply to the
   *       function.

   */
  Tags?: { [key: string]: string };

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
A dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous events
   *       when they fail processing. For more information, see Dead Letter Queues.

   */
  DeadLetterConfig?: DeadLetterConfig;
}


/**
 *
The dead-letter queue for
 *       failed asynchronous invocations.

 */
export interface DeadLetterConfig {
  __type?: "DeadLetterConfig";
  /**
   *
The Amazon Resource Name (ARN) of an Amazon SQS queue or Amazon SNS topic.

   */
  TargetArn?: string;
}


export interface DeleteAliasRequest {
  __type?: "DeleteAliasRequest";
  /**
   *
The name of the alias.

   */
  Name: string | undefined;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - MyFunction.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:MyFunction.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;
}


export interface DeleteEventSourceMappingRequest {
  __type?: "DeleteEventSourceMappingRequest";
  /**
   *
The identifier of the event source mapping.

   */
  UUID: string | undefined;
}


export interface DeleteFunctionConcurrencyRequest {
  __type?: "DeleteFunctionConcurrencyRequest";
  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;
}


export interface DeleteFunctionEventInvokeConfigRequest {
  __type?: "DeleteFunctionEventInvokeConfigRequest";
  /**
   *
A version number or alias name.

   */
  Qualifier?: string;

  /**
   *
The name of the Lambda function, version, or alias.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:v1 (with alias).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;
}


export interface DeleteFunctionRequest {
  __type?: "DeleteFunctionRequest";
  /**
   *
The name of the Lambda function or version.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:1 (with version).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
Specify a version to delete. You can't delete a version that's referenced by an alias.

   */
  Qualifier?: string;
}


export interface DeleteLayerVersionRequest {
  __type?: "DeleteLayerVersionRequest";
  /**
   *
The name or Amazon Resource Name (ARN) of the layer.

   */
  LayerName: string | undefined;

  /**
   *
The version number.

   */
  VersionNumber: number | undefined;
}


export interface DeleteProvisionedConcurrencyConfigRequest {
  __type?: "DeleteProvisionedConcurrencyConfigRequest";
  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
The version number or alias name.

   */
  Qualifier: string | undefined;
}


/**
 *
A configuration object that specifies the destination of an event after Lambda processes it.

 */
export interface DestinationConfig {
  __type?: "DestinationConfig";
  /**
   *
The destination configuration for successful invocations.

   */
  OnSuccess?: OnSuccess;

  /**
   *
The destination configuration for failed invocations.

   */
  OnFailure?: OnFailure;
}


/**
 *
Need additional permissions to configure VPC settings.

 */
export interface EC2AccessDeniedException extends __SmithyException, $MetadataBearer {
  name: "EC2AccessDeniedException";
  $fault: "server";
  Type?: string;
  Message?: string;
}


/**
 *
AWS Lambda was throttled by Amazon EC2 during Lambda function initialization using the execution role provided
 *       for the Lambda function.

 */
export interface EC2ThrottledException extends __SmithyException, $MetadataBearer {
  name: "EC2ThrottledException";
  $fault: "server";
  Type?: string;
  Message?: string;
}


/**
 *
AWS Lambda received an unexpected EC2 client exception while setting up for the Lambda function.

 */
export interface EC2UnexpectedException extends __SmithyException, $MetadataBearer {
  name: "EC2UnexpectedException";
  $fault: "server";
  Type?: string;
  EC2ErrorCode?: string;
  Message?: string;
}


/**
 *
An error occured when reading from or writing to a connected file system.

 */
export interface EFSIOException extends __SmithyException, $MetadataBearer {
  name: "EFSIOException";
  $fault: "client";
  Message?: string;
  Type?: string;
}


/**
 *
The function couldn't make a network connection to the configured file system.

 */
export interface EFSMountConnectivityException extends __SmithyException, $MetadataBearer {
  name: "EFSMountConnectivityException";
  $fault: "client";
  Type?: string;
  Message?: string;
}


/**
 *
The function couldn't mount the configured file system due to a permission or configuration issue.

 */
export interface EFSMountFailureException extends __SmithyException, $MetadataBearer {
  name: "EFSMountFailureException";
  $fault: "client";
  Message?: string;
  Type?: string;
}


/**
 *
The function was able to make a network connection to the configured file system, but the mount operation
 *       timed out.

 */
export interface EFSMountTimeoutException extends __SmithyException, $MetadataBearer {
  name: "EFSMountTimeoutException";
  $fault: "client";
  Type?: string;
  Message?: string;
}


/**
 *
AWS Lambda was not able to create an elastic network interface in the VPC, specified as part of Lambda
 *       function configuration, because the limit for network interfaces has been reached.

 */
export interface ENILimitReachedException extends __SmithyException, $MetadataBearer {
  name: "ENILimitReachedException";
  $fault: "server";
  Message?: string;
  Type?: string;
}


/**
 *
A function's environment variable settings.

 */
export interface Environment {
  __type?: "Environment";
  /**
   *
Environment variable key-value pairs.

   */
  Variables?: { [key: string]: string };
}


/**
 *
Error messages for environment variables that couldn't be applied.

 */
export interface EnvironmentError {
  __type?: "EnvironmentError";
  /**
   *
The error message.

   */
  Message?: string;

  /**
   *
The error code.

   */
  ErrorCode?: string;
}


/**
 *
The results of an operation to update or read environment variables. If the operation is successful, the
 *       response contains the environment variables. If it failed, the response contains details about the error.

 */
export interface EnvironmentResponse {
  __type?: "EnvironmentResponse";
  /**
   *
Environment variable key-value pairs.

   */
  Variables?: { [key: string]: string };

  /**
   *
Error messages for environment variables that couldn't be applied.

   */
  Error?: EnvironmentError;
}


/**
 *
A mapping between an AWS resource and an AWS Lambda function. See CreateEventSourceMapping
 *       for details.

 */
export interface EventSourceMappingConfiguration {
  __type?: "EventSourceMappingConfiguration";
  /**
   *
The state of the event source mapping. It can be one of the following: Creating,
   *         Enabling, Enabled, Disabling, Disabled,
   *         Updating, or Deleting.

   */
  State?: string;

  /**
   *
(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.

   */
  DestinationConfig?: DestinationConfig;

  /**
   *
(Streams) The maximum amount of time to gather records before invoking the function, in seconds.

   */
  MaximumBatchingWindowInSeconds?: number;

  /**
   *
(Streams) The maximum number of times to retry when the function returns an error.

   */
  MaximumRetryAttempts?: number;

  /**
   *
The maximum number of items to retrieve in a single batch.

   */
  BatchSize?: number;

  /**
   *
The result of the last AWS Lambda invocation of your Lambda function.

   */
  LastProcessingResult?: string;

  /**
   *
(Streams) The number of batches to process from each shard concurrently.

   */
  ParallelizationFactor?: number;

  /**
   *
(Streams) If the function returns an error, split the batch in two and retry.

   */
  BisectBatchOnFunctionError?: boolean;

  /**
   *
Indicates whether the last change to the event source mapping was made by a user, or by the Lambda
   *       service.

   */
  StateTransitionReason?: string;

  /**
   *
(Streams) The maximum age of a record that Lambda sends to a function for processing.

   */
  MaximumRecordAgeInSeconds?: number;

  /**
   *
The date that the event source mapping was last updated, or its state changed.

   */
  LastModified?: Date;

  /**
   *
The ARN of the Lambda function.

   */
  FunctionArn?: string;

  /**
   *
The Amazon Resource Name (ARN) of the event source.

   */
  EventSourceArn?: string;

  /**
   *
The identifier of the event source mapping.

   */
  UUID?: string;
}


/**
 *
Details about the connection between a Lambda function and an Amazon EFS file system.

 */
export interface FileSystemConfig {
  __type?: "FileSystemConfig";
  /**
   *
The Amazon Resource Name (ARN) of the Amazon EFS access point that provides access to the file system.

   */
  Arn: string | undefined;

  /**
   *
The path where the function can access the file system, starting with /mnt/.

   */
  LocalMountPath: string | undefined;
}


/**
 *
The code for the Lambda function. You can specify either an object in Amazon S3, or upload a deployment
 *       package directly.

 */
export interface FunctionCode {
  __type?: "FunctionCode";
  /**
   *
For versioned objects, the version of the deployment package object to use.

   */
  S3ObjectVersion?: string;

  /**
   *
An Amazon S3 bucket in the same AWS Region as your function. The bucket can be in a different AWS account.

   */
  S3Bucket?: string;

  /**
   *
The Amazon S3 key of the deployment package.

   */
  S3Key?: string;

  /**
   *
The base64-encoded contents of the deployment package. AWS SDK and AWS CLI clients handle the encoding for
   *   you.

   */
  ZipFile?: Uint8Array;
}


/**
 *
Details about a function's deployment package.

 */
export interface FunctionCodeLocation {
  __type?: "FunctionCodeLocation";
  /**
   *
A presigned URL that you can use to download the deployment package.

   */
  Location?: string;

  /**
   *
The service that's hosting the file.

   */
  RepositoryType?: string;
}


/**
 *
Details about a function's configuration.

 */
export interface FunctionConfiguration {
  __type?: "FunctionConfiguration";
  /**
   *
The name of the function.

   */
  FunctionName?: string;

  /**
   *
The latest updated revision of the function or alias.

   */
  RevisionId?: string;

  /**
   *
For Lambda@Edge functions, the ARN of the master function.

   */
  MasterArn?: string;

  /**
   *
The status of the last update that was performed on the function. This is first set to Successful
   *       after function creation completes.

   */
  LastUpdateStatus?: LastUpdateStatus | string;

  /**
   *
The function's
   *       layers.

   */
  Layers?: Layer[];

  /**
   *
Connection settings for an Amazon EFS file system.

   */
  FileSystemConfigs?: FileSystemConfig[];

  /**
   *
The function's networking configuration.

   */
  VpcConfig?: VpcConfigResponse;

  /**
   *
The runtime environment for the Lambda function.

   */
  Runtime?: Runtime | string;

  /**
   *
The SHA256 hash of the function's deployment package.

   */
  CodeSha256?: string;

  /**
   *
The date and time that the function was last updated, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).

   */
  LastModified?: string;

  /**
   *
The memory that's allocated to the function.

   */
  MemorySize?: number;

  /**
   *
The version of the Lambda function.

   */
  Version?: string;

  /**
   *
The amount of time in seconds that Lambda allows a function to run before stopping it.

   */
  Timeout?: number;

  /**
   *
The size of the function's deployment package, in bytes.

   */
  CodeSize?: number;

  /**
   *
The function's Amazon Resource Name (ARN).

   */
  FunctionArn?: string;

  /**
   *
The function's environment variables.

   */
  Environment?: EnvironmentResponse;

  /**
   *
The reason for the last update that was performed on the function.

   */
  LastUpdateStatusReason?: string;

  /**
   *
The function that Lambda calls to begin executing your function.

   */
  Handler?: string;

  /**
   *
The function's AWS X-Ray tracing configuration.

   */
  TracingConfig?: TracingConfigResponse;

  /**
   *
The reason code for the function's current state. When the code is Creating, you can't invoke or
   *       modify the function.

   */
  StateReasonCode?: StateReasonCode | string;

  /**
   *
The reason code for the last update that was performed on the function.

   */
  LastUpdateStatusReasonCode?: LastUpdateStatusReasonCode | string;

  /**
   *
The function's description.

   */
  Description?: string;

  /**
   *
The function's execution role.

   */
  Role?: string;

  /**
   *
The KMS key that's used to encrypt the function's environment variables. This key is only returned if you've
   *       configured a customer managed CMK.

   */
  KMSKeyArn?: string;

  /**
   *
The function's dead letter queue.

   */
  DeadLetterConfig?: DeadLetterConfig;

  /**
   *
The reason for the function's current state.

   */
  StateReason?: string;

  /**
   *
The current state of the function. When the state is Inactive, you can reactivate the function by
   *       invoking it.

   */
  State?: State | string;
}


export interface FunctionEventInvokeConfig {
  __type?: "FunctionEventInvokeConfig";
  /**
   *
The maximum age of a request that Lambda sends to a function for processing.

   */
  MaximumEventAgeInSeconds?: number;

  /**
   *
A destination for events after they have been sent to a function for processing.

   *

   *             Destinations
   *

   *

   *

   *

   *                   Function - The Amazon Resource Name (ARN) of a Lambda function.

   *

   *

   *

   *                   Queue - The ARN of an SQS queue.

   *

   *

   *

   *                   Topic - The ARN of an SNS topic.

   *

   *

   *

   *                   Event Bus - The ARN of an Amazon EventBridge event bus.

   *

   *

   */
  DestinationConfig?: DestinationConfig;

  /**
   *
The date and time that the configuration was last updated.

   */
  LastModified?: Date;

  /**
   *
The maximum number of times to retry when the function returns an error.

   */
  MaximumRetryAttempts?: number;

  /**
   *
The Amazon Resource Name (ARN) of the function.

   */
  FunctionArn?: string;
}


export interface GetAccountSettingsRequest {
  __type?: "GetAccountSettingsRequest";
}


export interface GetAccountSettingsResponse {
  __type?: "GetAccountSettingsResponse";
  /**
   *
Limits that are related to concurrency and code storage.

   */
  AccountLimit?: AccountLimit;

  /**
   *
The number of functions and amount of storage in use.

   */
  AccountUsage?: AccountUsage;
}


export interface GetAliasRequest {
  __type?: "GetAliasRequest";
  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - MyFunction.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:MyFunction.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
The name of the alias.

   */
  Name: string | undefined;
}


export interface GetEventSourceMappingRequest {
  __type?: "GetEventSourceMappingRequest";
  /**
   *
The identifier of the event source mapping.

   */
  UUID: string | undefined;
}


export interface GetFunctionConcurrencyRequest {
  __type?: "GetFunctionConcurrencyRequest";
  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;
}


export interface GetFunctionConcurrencyResponse {
  __type?: "GetFunctionConcurrencyResponse";
  /**
   *
The number of simultaneous executions that are reserved for the function.

   */
  ReservedConcurrentExecutions?: number;
}


export interface GetFunctionConfigurationRequest {
  __type?: "GetFunctionConfigurationRequest";
  /**
   *
The name of the Lambda function, version, or alias.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:v1 (with alias).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
Specify a version or alias to get details about a published version of the function.

   */
  Qualifier?: string;
}


export interface GetFunctionEventInvokeConfigRequest {
  __type?: "GetFunctionEventInvokeConfigRequest";
  /**
   *
A version number or alias name.

   */
  Qualifier?: string;

  /**
   *
The name of the Lambda function, version, or alias.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:v1 (with alias).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;
}


export interface GetFunctionRequest {
  __type?: "GetFunctionRequest";
  /**
   *
Specify a version or alias to get details about a published version of the function.

   */
  Qualifier?: string;

  /**
   *
The name of the Lambda function, version, or alias.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:v1 (with alias).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;
}


export interface GetFunctionResponse {
  __type?: "GetFunctionResponse";
  /**
   *
The function's tags.

   */
  Tags?: { [key: string]: string };

  /**
   *
The deployment package of the function or version.

   */
  Code?: FunctionCodeLocation;

  /**
   *
The function's reserved
   *         concurrency.

   */
  Concurrency?: Concurrency;

  /**
   *
The configuration of the function or version.

   */
  Configuration?: FunctionConfiguration;
}


export interface GetLayerVersionByArnRequest {
  __type?: "GetLayerVersionByArnRequest";
  /**
   *
The ARN of the layer version.

   */
  Arn: string | undefined;
}


export interface GetLayerVersionPolicyRequest {
  __type?: "GetLayerVersionPolicyRequest";
  /**
   *
The version number.

   */
  VersionNumber: number | undefined;

  /**
   *
The name or Amazon Resource Name (ARN) of the layer.

   */
  LayerName: string | undefined;
}


export interface GetLayerVersionPolicyResponse {
  __type?: "GetLayerVersionPolicyResponse";
  /**
   *
The policy document.

   */
  Policy?: string;

  /**
   *
A unique identifier for the current revision of the policy.

   */
  RevisionId?: string;
}


export interface GetLayerVersionRequest {
  __type?: "GetLayerVersionRequest";
  /**
   *
The name or Amazon Resource Name (ARN) of the layer.

   */
  LayerName: string | undefined;

  /**
   *
The version number.

   */
  VersionNumber: number | undefined;
}


export interface GetLayerVersionResponse {
  __type?: "GetLayerVersionResponse";
  /**
   *
The layer's software license.

   */
  LicenseInfo?: string;

  /**
   *
The layer's compatible runtimes.

   */
  CompatibleRuntimes?: (Runtime | string)[];

  /**
   *
The description of the version.

   */
  Description?: string;

  /**
   *
The ARN of the layer version.

   */
  LayerVersionArn?: string;

  /**
   *
The version number.

   */
  Version?: number;

  /**
   *
Details about the layer version.

   */
  Content?: LayerVersionContentOutput;

  /**
   *
The date that the layer version was created, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).

   */
  CreatedDate?: string;

  /**
   *
The ARN of the layer.

   */
  LayerArn?: string;
}


export interface GetPolicyRequest {
  __type?: "GetPolicyRequest";
  /**
   *
The name of the Lambda function, version, or alias.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:v1 (with alias).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
Specify a version or alias to get the policy for that resource.

   */
  Qualifier?: string;
}


export interface GetPolicyResponse {
  __type?: "GetPolicyResponse";
  /**
   *
The resource-based policy.

   */
  Policy?: string;

  /**
   *
A unique identifier for the current revision of the policy.

   */
  RevisionId?: string;
}


export interface GetProvisionedConcurrencyConfigRequest {
  __type?: "GetProvisionedConcurrencyConfigRequest";
  /**
   *
The version number or alias name.

   */
  Qualifier: string | undefined;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;
}


export interface GetProvisionedConcurrencyConfigResponse {
  __type?: "GetProvisionedConcurrencyConfigResponse";
  /**
   *
The amount of provisioned concurrency requested.

   */
  RequestedProvisionedConcurrentExecutions?: number;

  /**
   *
The amount of provisioned concurrency available.

   */
  AvailableProvisionedConcurrentExecutions?: number;

  /**
   *
For failed allocations, the reason that provisioned concurrency could not be allocated.

   */
  StatusReason?: string;

  /**
   *
The date and time that a user last updated the configuration, in ISO 8601 format.

   */
  LastModified?: string;

  /**
   *
The status of the allocation process.

   */
  Status?: ProvisionedConcurrencyStatusEnum | string;

  /**
   *
The amount of provisioned concurrency allocated.

   */
  AllocatedProvisionedConcurrentExecutions?: number;
}


/**
 *
One of the parameters in the request is invalid.

 */
export interface InvalidParameterValueException extends __SmithyException, $MetadataBearer {
  name: "InvalidParameterValueException";
  $fault: "client";
  /**
   *
The exception message.

   */
  message?: string;

  /**
   *
The exception type.

   */
  Type?: string;
}


/**
 *
The request body could not be parsed as JSON.

 */
export interface InvalidRequestContentException extends __SmithyException, $MetadataBearer {
  name: "InvalidRequestContentException";
  $fault: "client";
  /**
   *
The exception message.

   */
  message?: string;

  /**
   *
The exception type.

   */
  Type?: string;
}


/**
 *
The runtime or runtime version specified is not supported.

 */
export interface InvalidRuntimeException extends __SmithyException, $MetadataBearer {
  name: "InvalidRuntimeException";
  $fault: "server";
  Message?: string;
  Type?: string;
}


/**
 *
The Security Group ID provided in the Lambda function VPC configuration is invalid.

 */
export interface InvalidSecurityGroupIDException extends __SmithyException, $MetadataBearer {
  name: "InvalidSecurityGroupIDException";
  $fault: "server";
  Message?: string;
  Type?: string;
}


/**
 *
The Subnet ID provided in the Lambda function VPC configuration is invalid.

 */
export interface InvalidSubnetIDException extends __SmithyException, $MetadataBearer {
  name: "InvalidSubnetIDException";
  $fault: "server";
  Type?: string;
  Message?: string;
}


/**
 *
AWS Lambda could not unzip the deployment package.

 */
export interface InvalidZipFileException extends __SmithyException, $MetadataBearer {
  name: "InvalidZipFileException";
  $fault: "server";
  Message?: string;
  Type?: string;
}


export interface InvocationRequest {
  __type?: "InvocationRequest";
  /**
   *
Choose from the following options.

   *

   *

   *

   *                   RequestResponse (default) - Invoke the function synchronously. Keep the connection open until
   *           the function returns a response or times out. The API response includes the function response and additional
   *           data.

   *

   *

   *

   *                   Event - Invoke the function asynchronously. Send events that fail multiple times to the
   *           function's dead-letter queue (if it's configured). The API response only includes a status code.

   *

   *

   *

   *                   DryRun - Validate parameter values and verify that the user or role has permission to invoke
   *           the function.

   *

   *

   */
  InvocationType?: InvocationType | string;

  /**
   *
Set to Tail to include the execution log in the response.

   */
  LogType?: LogType | string;

  /**
   *
The JSON that you want to provide to your Lambda function as input.

   */
  Payload?: Uint8Array;

  /**
   *
Specify a version or alias to invoke a published version of the function.

   */
  Qualifier?: string;

  /**
   *
Up to 3583 bytes of base64-encoded data about the invoking client to pass to the function in the context
   *       object.

   */
  ClientContext?: string;

  /**
   *
The name of the Lambda function, version, or alias.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:v1 (with alias).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;
}


export interface InvocationResponse {
  __type?: "InvocationResponse";
  /**
   *
The last 4 KB of the execution log, which is base64 encoded.

   */
  LogResult?: string;

  /**
   *
The response from the function, or an error object.

   */
  Payload?: Uint8Array;

  /**
   *
The version of the function that executed. When you invoke a function with an alias, this indicates which
   *       version the alias resolved to.

   */
  ExecutedVersion?: string;

  /**
   *
If present, indicates that an error occurred during function execution. Details about the error are included
   *       in the response payload.

   */
  FunctionError?: string;
}


export interface InvokeAsyncRequest {
  __type?: "InvokeAsyncRequest";
  /**
   *
The JSON that you want to provide to your Lambda function as input.

   */
  InvokeArgs: Readable | ReadableStream | Blob | undefined;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;
}


/**
 *
A success response (202 Accepted) indicates that the request is queued for invocation.

 */
export interface InvokeAsyncResponse {
  __type?: "InvokeAsyncResponse";
}


/**
 *
Lambda was unable to decrypt the environment variables because KMS access was denied. Check the Lambda
 *       function's KMS permissions.

 */
export interface KMSAccessDeniedException extends __SmithyException, $MetadataBearer {
  name: "KMSAccessDeniedException";
  $fault: "server";
  Message?: string;
  Type?: string;
}


/**
 *
Lambda was unable to decrypt the environment variables because the KMS key used is disabled. Check the Lambda
 *       function's KMS key settings.

 */
export interface KMSDisabledException extends __SmithyException, $MetadataBearer {
  name: "KMSDisabledException";
  $fault: "server";
  Type?: string;
  Message?: string;
}


/**
 *
Lambda was unable to decrypt the environment variables because the KMS key used is in an invalid state for
 *       Decrypt. Check the function's KMS key settings.

 */
export interface KMSInvalidStateException extends __SmithyException, $MetadataBearer {
  name: "KMSInvalidStateException";
  $fault: "server";
  Type?: string;
  Message?: string;
}


/**
 * <p>Lambda was unable to decrypt the environment variables because the KMS key was not found. Check the function's
 *       KMS key settings. </p>
 */
export interface KMSNotFoundException extends __SmithyException, $MetadataBearer {
  name: "KMSNotFoundException";
  $fault: "server";
  Type?: string;
  Message?: string;
}


/**
 *
An AWS Lambda
 *         layer.

 */
export interface Layer {
  __type?: "Layer";
  /**
   *
The Amazon Resource Name (ARN) of the function layer.

   */
  Arn?: string;

  /**
   *
The size of the layer archive in bytes.

   */
  CodeSize?: number;
}


/**
 *
Details about an AWS Lambda
 *         layer.

 */
export interface LayersListItem {
  __type?: "LayersListItem";
  /**
   *
The Amazon Resource Name (ARN) of the function layer.

   */
  LayerArn?: string;

  /**
   *
The name of the layer.

   */
  LayerName?: string;

  /**
   *
The newest version of the layer.

   */
  LatestMatchingVersion?: LayerVersionsListItem;
}


/**
 *
A ZIP archive that contains the contents of an AWS Lambda
 *         layer. You can specify either an Amazon S3 location,
 *       or upload a layer archive directly.

 */
export interface LayerVersionContentInput {
  __type?: "LayerVersionContentInput";
  /**
   *
The Amazon S3 bucket of the layer archive.

   */
  S3Bucket?: string;

  /**
   *
For versioned objects, the version of the layer archive object to use.

   */
  S3ObjectVersion?: string;

  /**
   *
The Amazon S3 key of the layer archive.

   */
  S3Key?: string;

  /**
   *
The base64-encoded contents of the layer archive. AWS SDK and AWS CLI clients handle the encoding for
   *       you.

   */
  ZipFile?: Uint8Array;
}


/**
 *
Details about a version of an AWS Lambda
 *         layer.

 */
export interface LayerVersionContentOutput {
  __type?: "LayerVersionContentOutput";
  /**
   *
The SHA-256 hash of the layer archive.

   */
  CodeSha256?: string;

  /**
   *
The size of the layer archive in bytes.

   */
  CodeSize?: number;

  /**
   *
A link to the layer archive in Amazon S3 that is valid for 10 minutes.

   */
  Location?: string;
}


/**
 *
Details about a version of an AWS Lambda
 *         layer.

 */
export interface LayerVersionsListItem {
  __type?: "LayerVersionsListItem";
  /**
   *
The date that the version was created, in ISO 8601 format. For example, 2018-11-27T15:10:45.123+0000.

   */
  CreatedDate?: string;

  /**
   *
The version number.

   */
  Version?: number;

  /**
   *
The layer's open-source license.

   */
  LicenseInfo?: string;

  /**
   *
The layer's compatible runtimes.

   */
  CompatibleRuntimes?: (Runtime | string)[];

  /**
   *
The description of the version.

   */
  Description?: string;

  /**
   *
The ARN of the layer version.

   */
  LayerVersionArn?: string;
}


export interface ListAliasesRequest {
  __type?: "ListAliasesRequest";
  /**
   *
Specify the pagination token that's returned by a previous request to retrieve the next page of results.

   */
  Marker?: string;

  /**
   *
Limit the number of aliases returned.

   */
  MaxItems?: number;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - MyFunction.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:MyFunction.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
Specify a function version to only list aliases that invoke that version.

   */
  FunctionVersion?: string;
}


export interface ListAliasesResponse {
  __type?: "ListAliasesResponse";
  /**
   *
A list of aliases.

   */
  Aliases?: AliasConfiguration[];

  /**
   *
The pagination token that's included if more results are available.

   */
  NextMarker?: string;
}


export interface ListEventSourceMappingsRequest {
  __type?: "ListEventSourceMappingsRequest";
  /**
   *
A pagination token returned by a previous call.

   */
  Marker?: string;

  /**
   *
The maximum number of event source mappings to return.

   */
  MaxItems?: number;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - MyFunction.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.

   *

   *

   *

   *                   Version or Alias ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction:PROD.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:MyFunction.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it's limited to 64
   *       characters in length.

   */
  FunctionName?: string;

  /**
   *
The Amazon Resource Name (ARN) of the event source.

   *

   *

   *

   *                   Amazon Kinesis - The ARN of the data stream or a stream consumer.

   *

   *

   *

   *                   Amazon DynamoDB Streams - The ARN of the stream.

   *

   *

   *

   *                   Amazon Simple Queue Service - The ARN of the queue.

   *

   *

   */
  EventSourceArn?: string;
}


export interface ListEventSourceMappingsResponse {
  __type?: "ListEventSourceMappingsResponse";
  /**
   *
A pagination token that's returned when the response doesn't contain all event source mappings.

   */
  NextMarker?: string;

  /**
   *
A list of event source mappings.

   */
  EventSourceMappings?: EventSourceMappingConfiguration[];
}


export interface ListFunctionEventInvokeConfigsRequest {
  __type?: "ListFunctionEventInvokeConfigsRequest";
  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
The maximum number of configurations to return.

   */
  MaxItems?: number;

  /**
   *
Specify the pagination token that's returned by a previous request to retrieve the next page of results.

   */
  Marker?: string;
}


export interface ListFunctionEventInvokeConfigsResponse {
  __type?: "ListFunctionEventInvokeConfigsResponse";
  /**
   *
The pagination token that's included if more results are available.

   */
  NextMarker?: string;

  /**
   *
A list of configurations.

   */
  FunctionEventInvokeConfigs?: FunctionEventInvokeConfig[];
}


export interface ListFunctionsRequest {
  __type?: "ListFunctionsRequest";
  /**
   *
Set to ALL to include entries for all published versions of each function.

   */
  FunctionVersion?: FunctionVersion | string;

  /**
   *
The maximum number of functions to return.

   */
  MaxItems?: number;

  /**
   *
For Lambda@Edge functions, the AWS Region of the master function. For example, us-east-1 filters
   *       the list of functions to only include Lambda@Edge functions replicated from a master function in US East (N.
   *       Virginia). If specified, you must set FunctionVersion to ALL.

   */
  MasterRegion?: string;

  /**
   *
Specify the pagination token that's returned by a previous request to retrieve the next page of results.

   */
  Marker?: string;
}


/**
 *
A list of Lambda functions.

 */
export interface ListFunctionsResponse {
  __type?: "ListFunctionsResponse";
  /**
   *
A list of Lambda functions.

   */
  Functions?: FunctionConfiguration[];

  /**
   *
The pagination token that's included if more results are available.

   */
  NextMarker?: string;
}


export interface ListLayersRequest {
  __type?: "ListLayersRequest";
  /**
   *
The maximum number of layers to return.

   */
  MaxItems?: number;

  /**
   *
A runtime identifier. For example, go1.x.

   */
  CompatibleRuntime?: Runtime | string;

  /**
   *
A pagination token returned by a previous call.

   */
  Marker?: string;
}


export interface ListLayersResponse {
  __type?: "ListLayersResponse";
  /**
   *
A pagination token returned when the response doesn't contain all layers.

   */
  NextMarker?: string;

  /**
   *
A list of function layers.

   */
  Layers?: LayersListItem[];
}


export interface ListLayerVersionsRequest {
  __type?: "ListLayerVersionsRequest";
  /**
   *
A runtime identifier. For example, go1.x.

   */
  CompatibleRuntime?: Runtime | string;

  /**
   *
A pagination token returned by a previous call.

   */
  Marker?: string;

  /**
   *
The name or Amazon Resource Name (ARN) of the layer.

   */
  LayerName: string | undefined;

  /**
   *
The maximum number of versions to return.

   */
  MaxItems?: number;
}


export interface ListLayerVersionsResponse {
  __type?: "ListLayerVersionsResponse";
  /**
   *
A pagination token returned when the response doesn't contain all versions.

   */
  NextMarker?: string;

  /**
   *
A list of versions.

   */
  LayerVersions?: LayerVersionsListItem[];
}


export interface ListProvisionedConcurrencyConfigsRequest {
  __type?: "ListProvisionedConcurrencyConfigsRequest";
  /**
   *
Specify the pagination token that's returned by a previous request to retrieve the next page of results.

   */
  Marker?: string;

  /**
   *
Specify a number to limit the number of configurations returned.

   */
  MaxItems?: number;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;
}


export interface ListProvisionedConcurrencyConfigsResponse {
  __type?: "ListProvisionedConcurrencyConfigsResponse";
  /**
   *
A list of provisioned concurrency configurations.

   */
  ProvisionedConcurrencyConfigs?: ProvisionedConcurrencyConfigListItem[];

  /**
   *
The pagination token that's included if more results are available.

   */
  NextMarker?: string;
}


export interface ListTagsRequest {
  __type?: "ListTagsRequest";
  /**
   *
The function's Amazon Resource Name (ARN).

   */
  Resource: string | undefined;
}


export interface ListTagsResponse {
  __type?: "ListTagsResponse";
  /**
   *
The function's tags.

   */
  Tags?: { [key: string]: string };
}


export interface ListVersionsByFunctionRequest {
  __type?: "ListVersionsByFunctionRequest";
  /**
   *
Specify the pagination token that's returned by a previous request to retrieve the next page of results.

   */
  Marker?: string;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - MyFunction.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:MyFunction.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
The maximum number of versions to return.

   */
  MaxItems?: number;
}


export interface ListVersionsByFunctionResponse {
  __type?: "ListVersionsByFunctionResponse";
  /**
   *
A list of Lambda function versions.

   */
  Versions?: FunctionConfiguration[];

  /**
   *
The pagination token that's included if more results are available.

   */
  NextMarker?: string;
}


/**
 *
A destination for events that failed processing.

 */
export interface OnFailure {
  __type?: "OnFailure";
  /**
   *
The Amazon Resource Name (ARN) of the destination resource.

   */
  Destination?: string;
}


/**
 *
A destination for events that were processed successfully.

 */
export interface OnSuccess {
  __type?: "OnSuccess";
  /**
   *
The Amazon Resource Name (ARN) of the destination resource.

   */
  Destination?: string;
}


/**
 *
The permissions policy for the resource is too large. Learn more
 *

 */
export interface PolicyLengthExceededException extends __SmithyException, $MetadataBearer {
  name: "PolicyLengthExceededException";
  $fault: "client";
  message?: string;
  Type?: string;
}


/**
 *
The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
 *         GetFunction or the GetAlias API to retrieve the latest RevisionId for your
 *       resource.

 */
export interface PreconditionFailedException extends __SmithyException, $MetadataBearer {
  name: "PreconditionFailedException";
  $fault: "client";
  /**
   *
The exception type.

   */
  Type?: string;

  /**
   *
The exception message.

   */
  message?: string;
}


/**
 *
Details about the provisioned concurrency configuration for a function alias or version.

 */
export interface ProvisionedConcurrencyConfigListItem {
  __type?: "ProvisionedConcurrencyConfigListItem";
  /**
   *
The date and time that a user last updated the configuration, in ISO 8601 format.

   */
  LastModified?: string;

  /**
   *
The amount of provisioned concurrency allocated.

   */
  AllocatedProvisionedConcurrentExecutions?: number;

  /**
   *
The status of the allocation process.

   */
  Status?: ProvisionedConcurrencyStatusEnum | string;

  /**
   *
The amount of provisioned concurrency available.

   */
  AvailableProvisionedConcurrentExecutions?: number;

  /**
   *
For failed allocations, the reason that provisioned concurrency could not be allocated.

   */
  StatusReason?: string;

  /**
   *
The amount of provisioned concurrency requested.

   */
  RequestedProvisionedConcurrentExecutions?: number;

  /**
   *
The Amazon Resource Name (ARN) of the alias or version.

   */
  FunctionArn?: string;
}


/**
 *
The specified configuration does not exist.

 */
export interface ProvisionedConcurrencyConfigNotFoundException extends __SmithyException, $MetadataBearer {
  name: "ProvisionedConcurrencyConfigNotFoundException";
  $fault: "client";
  message?: string;
  Type?: string;
}


export interface PublishLayerVersionRequest {
  __type?: "PublishLayerVersionRequest";
  /**
   *
The function layer archive.

   */
  Content: LayerVersionContentInput | undefined;

  /**
   *
The description of the version.

   */
  Description?: string;

  /**
   *
The name or Amazon Resource Name (ARN) of the layer.

   */
  LayerName: string | undefined;

  /**
   *
A list of compatible function
   *         runtimes. Used for filtering with ListLayers and ListLayerVersions.

   */
  CompatibleRuntimes?: (Runtime | string)[];

  /**
   *
The layer's software license. It can be any of the following:

   *

   *

   *
An SPDX license identifier. For example,
   *           MIT.

   *

   *

   *
The URL of a license hosted on the internet. For example,
   *           https://opensource.org/licenses/MIT.

   *

   *

   *
The full text of the license.

   *

   *

   */
  LicenseInfo?: string;
}


export interface PublishLayerVersionResponse {
  __type?: "PublishLayerVersionResponse";
  /**
   *
The description of the version.

   */
  Description?: string;

  /**
   *
The ARN of the layer version.

   */
  LayerVersionArn?: string;

  /**
   *
The version number.

   */
  Version?: number;

  /**
   *
The date that the layer version was created, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).

   */
  CreatedDate?: string;

  /**
   *
The ARN of the layer.

   */
  LayerArn?: string;

  /**
   *
Details about the layer version.

   */
  Content?: LayerVersionContentOutput;

  /**
   *
The layer's compatible runtimes.

   */
  CompatibleRuntimes?: (Runtime | string)[];

  /**
   *
The layer's software license.

   */
  LicenseInfo?: string;
}


export interface PublishVersionRequest {
  __type?: "PublishVersionRequest";
  /**
   *
Only update the function if the revision ID matches the ID that's specified. Use this option to avoid
   *       publishing a version if the function configuration has changed since you last updated it.

   */
  RevisionId?: string;

  /**
   *
A description for the version to override the description in the function configuration.

   */
  Description?: string;

  /**
   *
Only publish a version if the hash value matches the value that's specified. Use this option to avoid
   *       publishing a version if the function code has changed since you last updated it. You can get the hash for the
   *       version that you uploaded from the output of UpdateFunctionCode.

   */
  CodeSha256?: string;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - MyFunction.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:MyFunction.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;
}


export interface PutFunctionConcurrencyRequest {
  __type?: "PutFunctionConcurrencyRequest";
  /**
   *
The number of simultaneous executions to reserve for the function.

   */
  ReservedConcurrentExecutions: number | undefined;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;
}


export interface PutFunctionEventInvokeConfigRequest {
  __type?: "PutFunctionEventInvokeConfigRequest";
  /**
   *
A version number or alias name.

   */
  Qualifier?: string;

  /**
   *
The maximum number of times to retry when the function returns an error.

   */
  MaximumRetryAttempts?: number;

  /**
   *
A destination for events after they have been sent to a function for processing.

   *

   *             Destinations
   *

   *

   *

   *

   *                   Function - The Amazon Resource Name (ARN) of a Lambda function.

   *

   *

   *

   *                   Queue - The ARN of an SQS queue.

   *

   *

   *

   *                   Topic - The ARN of an SNS topic.

   *

   *

   *

   *                   Event Bus - The ARN of an Amazon EventBridge event bus.

   *

   *

   */
  DestinationConfig?: DestinationConfig;

  /**
   *
The maximum age of a request that Lambda sends to a function for processing.

   */
  MaximumEventAgeInSeconds?: number;

  /**
   *
The name of the Lambda function, version, or alias.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:v1 (with alias).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;
}


export interface PutProvisionedConcurrencyConfigRequest {
  __type?: "PutProvisionedConcurrencyConfigRequest";
  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
The amount of provisioned concurrency to allocate for the version or alias.

   */
  ProvisionedConcurrentExecutions: number | undefined;

  /**
   *
The version number or alias name.

   */
  Qualifier: string | undefined;
}


export interface PutProvisionedConcurrencyConfigResponse {
  __type?: "PutProvisionedConcurrencyConfigResponse";
  /**
   *
The amount of provisioned concurrency available.

   */
  AvailableProvisionedConcurrentExecutions?: number;

  /**
   *
The status of the allocation process.

   */
  Status?: ProvisionedConcurrencyStatusEnum | string;

  /**
   *
For failed allocations, the reason that provisioned concurrency could not be allocated.

   */
  StatusReason?: string;

  /**
   *
The amount of provisioned concurrency requested.

   */
  RequestedProvisionedConcurrentExecutions?: number;

  /**
   *
The amount of provisioned concurrency allocated.

   */
  AllocatedProvisionedConcurrentExecutions?: number;

  /**
   *
The date and time that a user last updated the configuration, in ISO 8601 format.

   */
  LastModified?: string;
}


export interface RemoveLayerVersionPermissionRequest {
  __type?: "RemoveLayerVersionPermissionRequest";
  /**
   *
The version number.

   */
  VersionNumber: number | undefined;

  /**
   *
The name or Amazon Resource Name (ARN) of the layer.

   */
  LayerName: string | undefined;

  /**
   *
The identifier that was specified when the statement was added.

   */
  StatementId: string | undefined;

  /**
   *
Only update the policy if the revision ID matches the ID specified. Use this option to avoid modifying a
   *       policy that has changed since you last read it.

   */
  RevisionId?: string;
}


export interface RemovePermissionRequest {
  __type?: "RemovePermissionRequest";
  /**
   *
The name of the Lambda function, version, or alias.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:v1 (with alias).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
Statement ID of the permission to remove.

   */
  StatementId: string | undefined;

  /**
   *
Specify a version or alias to remove permissions from a published version of the function.

   */
  Qualifier?: string;

  /**
   *
Only update the policy if the revision ID matches the ID that's specified. Use this option to avoid modifying a
   *       policy that has changed since you last read it.

   */
  RevisionId?: string;
}


/**
 *
The request payload exceeded the Invoke request body JSON input limit. For more information, see
 *         Limits.

 */
export interface RequestTooLargeException extends __SmithyException, $MetadataBearer {
  name: "RequestTooLargeException";
  $fault: "client";
  Type?: string;
  message?: string;
}


/**
 *
The resource already exists, or another operation is in progress.

 */
export interface ResourceConflictException extends __SmithyException, $MetadataBearer {
  name: "ResourceConflictException";
  $fault: "client";
  /**
   *
The exception type.

   */
  Type?: string;

  /**
   *
The exception message.

   */
  message?: string;
}


/**
 *
The operation conflicts with the resource's availability. For example, you attempted to update an EventSource
 *       Mapping in CREATING, or tried to delete a EventSource mapping currently in the UPDATING state.

 */
export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
  name: "ResourceInUseException";
  $fault: "client";
  Type?: string;
  Message?: string;
}


/**
 *
The resource specified in the request does not exist.

 */
export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
  name: "ResourceNotFoundException";
  $fault: "client";
  Type?: string;
  Message?: string;
}


/**
 *
The function is inactive and its VPC connection is no longer available. Wait for the VPC connection to
 *       reestablish and try again.

 */
export interface ResourceNotReadyException extends __SmithyException, $MetadataBearer {
  name: "ResourceNotReadyException";
  $fault: "server";
  /**
   *
The exception message.

   */
  message?: string;

  /**
   *
The exception type.

   */
  Type?: string;
}


/**
 *
The AWS Lambda service encountered an internal error.

 */
export interface ServiceException extends __SmithyException, $MetadataBearer {
  name: "ServiceException";
  $fault: "server";
  Message?: string;
  Type?: string;
}


/**
 *
AWS Lambda was not able to set up VPC access for the Lambda function because one or more configured subnets
 *       has no available IP addresses.

 */
export interface SubnetIPAddressLimitReachedException extends __SmithyException, $MetadataBearer {
  name: "SubnetIPAddressLimitReachedException";
  $fault: "server";
  Type?: string;
  Message?: string;
}


export interface TagResourceRequest {
  __type?: "TagResourceRequest";
  /**
   *
A list of tags to apply to the function.

   */
  Tags: { [key: string]: string } | undefined;

  /**
   *
The function's Amazon Resource Name (ARN).

   */
  Resource: string | undefined;
}


/**
 *
The request throughput limit was exceeded.

 */
export interface TooManyRequestsException extends __SmithyException, $MetadataBearer {
  name: "TooManyRequestsException";
  $fault: "client";
  message?: string;
  /**
   *
The number of seconds the caller should wait before retrying.

   */
  retryAfterSeconds?: string;

  Type?: string;
  Reason?: ThrottleReason | string;
}


/**
 *
The function's AWS X-Ray tracing configuration. To sample and record incoming requests, set Mode
 *       to Active.

 */
export interface TracingConfig {
  __type?: "TracingConfig";
  /**
   *
The tracing mode.

   */
  Mode?: TracingMode | string;
}


/**
 *
The function's AWS X-Ray tracing configuration.

 */
export interface TracingConfigResponse {
  __type?: "TracingConfigResponse";
  /**
   *
The tracing mode.

   */
  Mode?: TracingMode | string;
}


/**
 *
The content type of the Invoke request body is not JSON.

 */
export interface UnsupportedMediaTypeException extends __SmithyException, $MetadataBearer {
  name: "UnsupportedMediaTypeException";
  $fault: "client";
  message?: string;
  Type?: string;
}


export interface UntagResourceRequest {
  __type?: "UntagResourceRequest";
  /**
   *
A list of tag keys to remove from the function.

   */
  TagKeys: string[] | undefined;

  /**
   *
The function's Amazon Resource Name (ARN).

   */
  Resource: string | undefined;
}


export interface UpdateAliasRequest {
  __type?: "UpdateAliasRequest";
  /**
   *
The name of the alias.

   */
  Name: string | undefined;

  /**
   *
The function version that the alias invokes.

   */
  FunctionVersion?: string;

  /**
   *
The routing
   *         configuration of the alias.

   */
  RoutingConfig?: AliasRoutingConfiguration;

  /**
   *
Only update the alias if the revision ID matches the ID that's specified. Use this option to avoid modifying
   *       an alias that has changed since you last read it.

   */
  RevisionId?: string;

  /**
   *
A description of the alias.

   */
  Description?: string;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - MyFunction.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:MyFunction.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;
}


export interface UpdateEventSourceMappingRequest {
  __type?: "UpdateEventSourceMappingRequest";
  /**
   *
Disables the event source mapping to pause polling and invocation.

   */
  Enabled?: boolean;

  /**
   *
(Streams) The maximum amount of time to gather records before invoking the function, in seconds.

   */
  MaximumBatchingWindowInSeconds?: number;

  /**
   *
(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.

   */
  DestinationConfig?: DestinationConfig;

  /**
   *
The identifier of the event source mapping.

   */
  UUID: string | undefined;

  /**
   *
The maximum number of items to retrieve in a single batch.

   *

   *

   *

   *                   Amazon Kinesis - Default 100. Max 10,000.

   *

   *

   *

   *                   Amazon DynamoDB Streams - Default 100. Max 1,000.

   *

   *

   *

   *                   Amazon Simple Queue Service - Default 10. Max 10.

   *

   *

   */
  BatchSize?: number;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - MyFunction.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.

   *

   *

   *

   *                   Version or Alias ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction:PROD.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:MyFunction.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it's limited to 64
   *       characters in length.

   */
  FunctionName?: string;

  /**
   *
(Streams) The maximum age of a record that Lambda sends to a function for processing.

   */
  MaximumRecordAgeInSeconds?: number;

  /**
   *
(Streams) The number of batches to process from each shard concurrently.

   */
  ParallelizationFactor?: number;

  /**
   *
(Streams) The maximum number of times to retry when the function returns an error.

   */
  MaximumRetryAttempts?: number;

  /**
   *
(Streams) If the function returns an error, split the batch in two and retry.

   */
  BisectBatchOnFunctionError?: boolean;
}


export interface UpdateFunctionCodeRequest {
  __type?: "UpdateFunctionCodeRequest";
  /**
   *
An Amazon S3 bucket in the same AWS Region as your function. The bucket can be in a different AWS account.

   */
  S3Bucket?: string;

  /**
   *
The Amazon S3 key of the deployment package.

   */
  S3Key?: string;

  /**
   *
For versioned objects, the version of the deployment package object to use.

   */
  S3ObjectVersion?: string;

  /**
   *
The base64-encoded contents of the deployment package. AWS SDK and AWS CLI clients handle the encoding for
   *       you.

   */
  ZipFile?: Uint8Array;

  /**
   *
Set to true to validate the request parameters and access permissions without modifying the function
   *       code.

   */
  DryRun?: boolean;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
Only update the function if the revision ID matches the ID that's specified. Use this option to avoid modifying a
   *       function that has changed since you last read it.

   */
  RevisionId?: string;

  /**
   *
Set to true to publish a new version of the function after updating the code. This has the same effect as
   *       calling PublishVersion separately.

   */
  Publish?: boolean;
}


export interface UpdateFunctionConfigurationRequest {
  __type?: "UpdateFunctionConfigurationRequest";
  /**
   *
Only update the function if the revision ID matches the ID that's specified. Use this option to avoid modifying a
   *       function that has changed since you last read it.

   */
  RevisionId?: string;

  /**
   *
The ARN of the AWS Key Management Service (AWS KMS) key that's used to encrypt your function's environment
   *       variables. If it's not provided, AWS Lambda uses a default service key.

   */
  KMSKeyArn?: string;

  /**
   *
The amount of memory that your function has access to. Increasing the function's memory also increases its CPU
   *       allocation. The default value is 128 MB. The value must be a multiple of 64 MB.

   */
  MemorySize?: number;

  /**
   *
A description of the function.

   */
  Description?: string;

  /**
   *
A list of function layers
   *       to add to the function's execution environment. Specify each layer by its ARN, including the version.

   */
  Layers?: string[];

  /**
   *
The name of the method within your code that Lambda calls to execute your function. The format includes the
   *       file name. It can also include namespaces and other qualifiers, depending on the runtime. For more information,
   *       see Programming Model.

   */
  Handler?: string;

  /**
   *
Set Mode to Active to sample and trace a subset of incoming requests with AWS
   *       X-Ray.

   */
  TracingConfig?: TracingConfig;

  /**
   *
The amount of time that Lambda allows a function to run before stopping it. The default is 3 seconds. The
   *       maximum allowed value is 900 seconds.

   */
  Timeout?: number;

  /**
   *
Connection settings for an Amazon EFS file system.

   */
  FileSystemConfigs?: FileSystemConfig[];

  /**
   *
The Amazon Resource Name (ARN) of the function's execution role.

   */
  Role?: string;

  /**
   *
The name of the Lambda function.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function.

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64
   *       characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
The identifier of the function's runtime.

   */
  Runtime?: Runtime | string;

  /**
   *
Environment variables that are accessible from function code during execution.

   */
  Environment?: Environment;

  /**
   *
A dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous events
   *       when they fail processing. For more information, see Dead Letter Queues.

   */
  DeadLetterConfig?: DeadLetterConfig;

  /**
   *
For network connectivity to AWS resources in a VPC, specify a list of security groups and subnets in the VPC.
   *       When you connect a function to a VPC, it can only access resources and the internet through that VPC. For more
   *       information, see VPC Settings.

   */
  VpcConfig?: VpcConfig;
}


export interface UpdateFunctionEventInvokeConfigRequest {
  __type?: "UpdateFunctionEventInvokeConfigRequest";
  /**
   *
The name of the Lambda function, version, or alias.

   *

   *             Name formats
   *

   *

   *

   *

   *                   Function name - my-function (name-only), my-function:v1 (with alias).

   *

   *

   *

   *                   Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

   *

   *

   *

   *                   Partial ARN - 123456789012:function:my-function.

   *

   *

   *
You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN.
   *       If you specify only the function name, it is limited to 64 characters in length.

   */
  FunctionName: string | undefined;

  /**
   *
The maximum age of a request that Lambda sends to a function for processing.

   */
  MaximumEventAgeInSeconds?: number;

  /**
   *
A version number or alias name.

   */
  Qualifier?: string;

  /**
   *
The maximum number of times to retry when the function returns an error.

   */
  MaximumRetryAttempts?: number;

  /**
   *
A destination for events after they have been sent to a function for processing.

   *

   *             Destinations
   *

   *

   *

   *

   *                   Function - The Amazon Resource Name (ARN) of a Lambda function.

   *

   *

   *

   *                   Queue - The ARN of an SQS queue.

   *

   *

   *

   *                   Topic - The ARN of an SNS topic.

   *

   *

   *

   *                   Event Bus - The ARN of an Amazon EventBridge event bus.

   *

   *

   */
  DestinationConfig?: DestinationConfig;
}


/**
 *
The VPC security groups and subnets that are attached to a Lambda function. For more information, see VPC Settings.

 */
export interface VpcConfig {
  __type?: "VpcConfig";
  /**
   *
A list of VPC subnet IDs.

   */
  SubnetIds?: string[];

  /**
   *
A list of VPC security groups IDs.

   */
  SecurityGroupIds?: string[];
}


/**
 *
The VPC security groups and subnets that are attached to a Lambda function.

 */
export interface VpcConfigResponse {
  __type?: "VpcConfigResponse";
  /**
   *
A list of VPC subnet IDs.

   */
  SubnetIds?: string[];

  /**
   *
A list of VPC security groups IDs.

   */
  SecurityGroupIds?: string[];

  /**
   *
The ID of the VPC.

   */
  VpcId?: string;
}


export enum EventSourcePosition {
  AT_TIMESTAMP = "AT_TIMESTAMP",
  LATEST = "LATEST",
  TRIM_HORIZON = "TRIM_HORIZON",
}


export enum FunctionVersion {
  ALL = "ALL",
}


export enum InvocationType {
  DryRun = "DryRun",
  Event = "Event",
  RequestResponse = "RequestResponse",
}


export enum LastUpdateStatus {
  Failed = "Failed",
  InProgress = "InProgress",
  Successful = "Successful",
}


export enum LastUpdateStatusReasonCode {
  EniLimitExceeded = "EniLimitExceeded",
  InsufficientRolePermissions = "InsufficientRolePermissions",
  InternalError = "InternalError",
  InvalidConfiguration = "InvalidConfiguration",
  InvalidSecurityGroup = "InvalidSecurityGroup",
  InvalidSubnet = "InvalidSubnet",
  SubnetOutOfIPAddresses = "SubnetOutOfIPAddresses",
}


export enum LogType {
  None = "None",
  Tail = "Tail",
}


export enum ProvisionedConcurrencyStatusEnum {
  FAILED = "FAILED",
  IN_PROGRESS = "IN_PROGRESS",
  READY = "READY",
}


export enum Runtime {
  dotnetcore10 = "dotnetcore1.0",
  dotnetcore20 = "dotnetcore2.0",
  dotnetcore21 = "dotnetcore2.1",
  dotnetcore31 = "dotnetcore3.1",
  go1x = "go1.x",
  java11 = "java11",
  java8 = "java8",
  nodejs = "nodejs",
  nodejs10x = "nodejs10.x",
  nodejs12x = "nodejs12.x",
  nodejs43 = "nodejs4.3",
  nodejs43edge = "nodejs4.3-edge",
  nodejs610 = "nodejs6.10",
  nodejs810 = "nodejs8.10",
  provided = "provided",
  python27 = "python2.7",
  python36 = "python3.6",
  python37 = "python3.7",
  python38 = "python3.8",
  ruby25 = "ruby2.5",
  ruby27 = "ruby2.7",
}


export enum State {
  Active = "Active",
  Failed = "Failed",
  Inactive = "Inactive",
  Pending = "Pending",
}


export enum StateReasonCode {
  Creating = "Creating",
  EniLimitExceeded = "EniLimitExceeded",
  Idle = "Idle",
  InsufficientRolePermissions = "InsufficientRolePermissions",
  InternalError = "InternalError",
  InvalidConfiguration = "InvalidConfiguration",
  InvalidSecurityGroup = "InvalidSecurityGroup",
  InvalidSubnet = "InvalidSubnet",
  Restoring = "Restoring",
  SubnetOutOfIPAddresses = "SubnetOutOfIPAddresses",
}


export enum ThrottleReason {
  CallerRateLimitExceeded = "CallerRateLimitExceeded",
  ConcurrentInvocationLimitExceeded = "ConcurrentInvocationLimitExceeded",
  FunctionInvocationRateLimitExceeded = "FunctionInvocationRateLimitExceeded",
  ReservedFunctionConcurrentInvocationLimitExceeded = "ReservedFunctionConcurrentInvocationLimitExceeded",
  ReservedFunctionInvocationRateLimitExceeded = "ReservedFunctionInvocationRateLimitExceeded",
}


export enum TracingMode {
  Active = "Active",
  PassThrough = "PassThrough",
}


() => {
  React.useEffect(() => {
    incModCount();
  }, []);

  return

    I'm component Comp_05_0494

;
}


() => {
    incModCount();
  }


/// <reference path="../../typings/jquery/jquery.d.ts" />
function helper(nodeList: NodeList) {
    for (var i = 0; i < nodeList.length; i++) {
        var article = <HTMLElement>nodeList[i];
        var divs = article.querySelectorAll('[data-lightbox]');
        var urls = $(divs).map((idx, div) => {
            return JSON.parse(div.getAttribute('data-lightbox'));
        }).toArray();
        article.setAttribute('data-imazip', JSON.stringify(urls));
    }
}


(idx, div) => {
            return JSON.parse(div.getAttribute('data-lightbox'));
        }


(records: MutationRecord[]) => {
    records.forEach((record) => {
        if (!$(record.target).is('#search_posts')) return;
        helper(record.addedNodes);
    })
}


(record) => {
        if (!$(record.target).is('#search_posts')) return;
        helper(record.addedNodes);
    }


@Controller('auth')
export class UserController {
    constructor(private readonly userService: UserService) {
    }

    @Post('/signup')
    async signUp(
        @Body() authCredentialsDto: AuthCredentialsDto
    ): Promise<void> {
        console.log(authCredentialsDto)
        return await this.userService.signUp(authCredentialsDto)
    }

    @UseGuards(LocalAuthGuard)
    @Post('signin')
    async signIn(@Request() req) {
        return this.userService.signIn(req.user)
    }

    @UseGuards(JwtAuthGuard)
    @Get('me')
    getMe(@Request() req) {
        return req.user;
    }
}


@Post('/signup')
    async signUp(
        @Body() authCredentialsDto: AuthCredentialsDto
    ): Promise<void> {
        console.log(authCredentialsDto)
        return await this.userService.signUp(authCredentialsDto)
    }


@UseGuards(LocalAuthGuard)
    @Post('signin')
    async signIn(@Request() req) {
        return this.userService.signIn(req.user)
    }


@UseGuards(JwtAuthGuard)
    @Get('me')
    getMe(@Request() req) {
        return req.user;
    }


@Component({
  selector: 'app-validation',
  templateUrl: './validation.component.html',
  styleUrls: ['./validation.component.scss']
})
export class ValidationComponent implements OnInit {
  slideway_lone: number = 260;

  slide_left: number = 0;
  plu_left: number = 0;
  plu_top: number = 0;
  embed_left: number = 0;
  embed_top: number = 0;

  mouseX_save: number;
  mouseY_save: number;

  slide_active: boolean = false;
  plu_in: boolean = false;
  img_show: boolean = false;
  slide_lock: boolean = false;
  tip_show: boolean = true;

  @Input() tip_unpass_show: boolean = false;
  @Output() success: EventEmitter<boolean> = new EventEmitter ();
  pass: string = "unknow";

  constructor() { }

  onSlideMouseDown ( event: any ): void {
  	this.mouseX_save = event.clientX;
  	this.slide_active = true;
  }

  onSlideMouseout () {
  	if ( !this.slide_active ) {
  	  this.img_show = false;
  	}
  }

  generateEmbed () {
  	this.embed_left = 262 / 2 + Math.floor ( ( 262 / 2 - 40 ) * Math.random () );
  	this.plu_top = this.embed_top = Math.floor ( ( 117 - 40 ) * Math.random () );
  }

  reset () {
  	this.slide_left = 0;
	this.plu_left = 0;
	this.plu_top = 0;
	this.embed_left = 0;
	this.embed_top = 0;
	this.pass = "unknow";
	this.slide_lock = false;
	this.tip_show = true;

	this.generateEmbed ();
  }

  ngOnInit() {
  	this.generateEmbed ();

    let _self = this;

  	window.addEventListener ( 'mousemove', function ( e ) {
      if ( !_self.slide_active || _self.slide_lock ) { return };

  	  let x = e.clientX;

  	  _self.slide_left = x - _self.mouseX_save;
  	  console.log ( _self.slide_left );

  	  if ( _self.slide_left < 0 ) { _self.slide_left = 0 }
  	  else if ( _self.slide_left > _self.slideway_lone - 38 ) { _self.slide_left = _self.slideway_lone - 38 };

  	  _self.plu_left = _self.slide_left;

  	  if ( Math.abs ( _self.plu_left - _self.embed_left ) < 3 ) {
  	  	_self.plu_in = true;
  	  }
  	  else {
  	  	_self.plu_in = false;
  	  }
  	} );

  	window.addEventListener ( 'mouseup', function ( e ) {
  	  if ( !_self.slide_active ) { return };

  	  if( Math.abs ( _self.plu_left - _self.embed_left ) < 3 ) {
  	    _self.pass = 'success';
  	    _self.img_show = false;
  	    _self.success.emit ( true );

  	  }
  	  else {
  	  	_self.pass = 'fail';
  	  	_self.success.emit ( false );
  	  }
  	  _self.slide_active = false;
  	  _self.slide_lock = true;
      _self.tip_show = false;
  	} )

  }

}


onSlideMouseDown ( event: any ): void {
  	this.mouseX_save = event.clientX;
  	this.slide_active = true;
  }


onSlideMouseout () {
  	if ( !this.slide_active ) {
  	  this.img_show = false;
  	}
  }


generateEmbed () {
  	this.embed_left = 262 / 2 + Math.floor ( ( 262 / 2 - 40 ) * Math.random () );
  	this.plu_top = this.embed_top = Math.floor ( ( 117 - 40 ) * Math.random () );
  }


reset () {
  	this.slide_left = 0;
	this.plu_left = 0;
	this.plu_top = 0;
	this.embed_left = 0;
	this.embed_top = 0;
	this.pass = "unknow";
	this.slide_lock = false;
	this.tip_show = true;

	this.generateEmbed ();
  }


ngOnInit() {
  	this.generateEmbed ();

    let _self = this;

  	window.addEventListener ( 'mousemove', function ( e ) {
      if ( !_self.slide_active || _self.slide_lock ) { return };

  	  let x = e.clientX;

  	  _self.slide_left = x - _self.mouseX_save;
  	  console.log ( _self.slide_left );

  	  if ( _self.slide_left < 0 ) { _self.slide_left = 0 }
  	  else if ( _self.slide_left > _self.slideway_lone - 38 ) { _self.slide_left = _self.slideway_lone - 38 };

  	  _self.plu_left = _self.slide_left;

  	  if ( Math.abs ( _self.plu_left - _self.embed_left ) < 3 ) {
  	  	_self.plu_in = true;
  	  }
  	  else {
  	  	_self.plu_in = false;
  	  }
  	} );

  	window.addEventListener ( 'mouseup', function ( e ) {
  	  if ( !_self.slide_active ) { return };

  	  if( Math.abs ( _self.plu_left - _self.embed_left ) < 3 ) {
  	    _self.pass = 'success';
  	    _self.img_show = false;
  	    _self.success.emit ( true );

  	  }
  	  else {
  	  	_self.pass = 'fail';
  	  	_self.success.emit ( false );
  	  }
  	  _self.slide_active = false;
  	  _self.slide_lock = true;
      _self.tip_show = false;
  	} )

  }


() => {
  return {
    provide: {
      isMobile: /iPhone|iPad|iPod|Android/i.test(navigator.userAgent)
    }
  };
}


function Home() {
  return (
    <Container>
      <VStack my={24} spacing={12}>
        <Heading as="h1" fontSize="9xl" textAlign="center">
          Dark
        </Heading>
        <Text fontSize="3xl" textAlign="center">
          An opinated, dark-themed Next.js & Chakra UI GitHub repository
          template
        </Text>
        <Text>
          Hit the ground running with one yarn install.
        </Text>
      </VStack>
    </Container>
  )
}


@NgModule({
  declarations: [
    AppComponent,
    SwaggerUiWrapperComponent,
    SpecificationOverviewComponent,
    SpecificationFormComponent,
    DiffVersionsComponent,
    HeaderComponent,
    SpecificationSearchComponent,
    SpecificationSearchDetailComponent,
    HighlightSearchResultPipe,
    TrimSearchResultPipe,
    FormatSearchResultPipe,
    LoginComponent,
    GraphiQLWrapperComponent,
    SpecificationViewComponent
  ],
  imports: [
    BrowserModule,
    HttpClientModule,
    FormsModule,
    ReactiveFormsModule,
    RouterModule.forRoot(
      appRoutes
    ),
    NgbModule.forRoot(),
    MarkdownModule.forRoot(),
    BrowserAnimationsModule
  ],
  providers: [
    AuthenticationGuard,
    AuthenticationService,
    { provide: HTTP_INTERCEPTORS, useClass: TokenInterceptor, multi: true },
    LoginEvent
  ],
  bootstrap: [AppComponent]
})
export class AppModule {
}


() => {
  let page: AppPage;

  beforeEach(() => {
    page = new AppPage();
  });

  it('should display welcome message', () => {
    page.navigateTo();
    expect(page.getTitleText()).toEqual('soscafe-vendor-app app is running!');
  });

  afterEach(async () => {
    // Assert that there are no errors emitted from the browser
    const logs = await browser.manage().logs().get(logging.Type.BROWSER);
    expect(logs).not.toContain(jasmine.objectContaining({
      level: logging.Level.SEVERE,
    } as logging.Entry));
  });
}


() => {
    page.navigateTo();
    expect(page.getTitleText()).toEqual('soscafe-vendor-app app is running!');
  }


(currentUser) => this.setState({currentUser})


(err) => {
        // Not logged in, no big deal
      }


(e: any) => {
    this.setState({title: e.target.value});
  }


(e: any) => {
    this.setState({subtitle: e.target.value});
  }


(color: any) => {
    this.setState({color: color.hex});
  }


() => {
    const {currentUser} = this.state;

    if (!currentUser) {
      return {};
    }

    const {id, email} = currentUser;

    // TODO: include name if available
    return {
      email: email,
      external_id: String(id),
    };
  }


class Demo extends React.Component<Props, State> {
  constructor(props: Props) {
    super(props);

    const q = qs.parse(props.location.search) || {};
    const defaultTitle = q.title ? String(q.title).trim() : null;
    const defaultSubtitle = q.subtitle ? String(q.subtitle).trim() : null;
    const defaultColor = q.color ? String(q.color).trim() : null;

    this.state = {
      color: defaultColor || colors.primary,
      title: defaultTitle || 'Welcome to Papercups!',
      subtitle: defaultSubtitle || 'Ask us anything using the chat window 💭',
      accountId: 'eb504736-0f20-4978-98ff-1a82ae60b266',
      currentUser: null,
    };
  }

  componentDidMount() {
    API.me()
      .then((currentUser) => this.setState({currentUser}))
      .catch((err) => {
        // Not logged in, no big deal
      });
  }

  handleChangeTitle = (e: any) => {
    this.setState({title: e.target.value});
  };

  handleChangeSubtitle = (e: any) => {
    this.setState({subtitle: e.target.value});
  };

  handleChangeColor = (color: any) => {
    this.setState({color: color.hex});
  };

  getCustomerMetadata = () => {
    const {currentUser} = this.state;

    if (!currentUser) {
      return {};
    }

    const {id, email} = currentUser;

    // TODO: include name if available
    return {
      email: email,
      external_id: String(id),
    };
  };

  render() {
    const {color, title, subtitle, accountId} = this.state;
    const customer = this.getCustomerMetadata();
    const defaultColors = [
      colors.primary,
      '#00B3BE',
      '#099720',
      '#7556EB',
      '#DE2828',
      '#F223C5',
      '#EC7F00',
      '#1E1F21',
      '#89603A',
      '#878784',
    ];

    return (
      <Box
        p={5}
        sx={{
          maxWidth: 720,
        }}


type Props = RouteComponentProps & {};


type State = {
  color: string;
  title: string;
  subtitle: string;
  accountId: string;
  currentUser?: any;
};


componentDidMount() {
    API.me()
      .then((currentUser) => this.setState({currentUser}))
      .catch((err) => {
        // Not logged in, no big deal
      });
  }


render() {
    const {color, title, subtitle, accountId} = this.state;
    const customer = this.getCustomerMetadata();
    const defaultColors = [
      colors.primary,
      '#00B3BE',
      '#099720',
      '#7556EB',
      '#DE2828',
      '#F223C5',
      '#EC7F00',
      '#1E1F21',
      '#89603A',
      '#878784',
    ];

    return (
      <Box
        p={5}
        sx={{
          maxWidth: 720,
        }}


() => {
  it('should add', () => {
    expect(new Cmp146Component().add146(1)).toBe(147);
  });
}


() => {
    expect(new Cmp146Component().add146(1)).toBe(147);
  }


@ApiTags('Coins')
@Controller('coins')
export class CoinController {
  constructor(private readonly coinService: CoinService) {}

  @Get()
  @ApiOperation({ description: "Find all the coin's records" })
  async all() {
    return this.coinService.listAllCoins();
  }

  @Post()
  @ApiOperation({ description: 'Update coin' })
  async add(@Body() coinDto: CoinDto) {
    return this.coinService.addCoin(coinDto);
  }

  @Put(':id')
  @ApiOperation({ description: 'Update coin' })
  async update(@Param('id') id: string, @Body() coinDto: UpdateCoinDto) {
    return this.coinService.updateCoin(id, coinDto);
  }

  @Delete(':id')
  delete(@Param('id') id: string) {
    return this.coinService.deleteCoin(id);
  }
}


@Get()
  @ApiOperation({ description: "Find all the coin's records" })
  async all() {
    return this.coinService.listAllCoins();
  }


@Post()
  @ApiOperation({ description: 'Update coin' })
  async add(@Body() coinDto: CoinDto) {
    return this.coinService.addCoin(coinDto);
  }


@Put(':id')
  @ApiOperation({ description: 'Update coin' })
  async update(@Param('id') id: string, @Body() coinDto: UpdateCoinDto) {
    return this.coinService.updateCoin(id, coinDto);
  }


@Delete(':id')
  delete(@Param('id') id: string) {
    return this.coinService.deleteCoin(id);
  }


() => {
          this.isLoadingResults = true;

          return this._associationService.getAssociations();
        }


data => {
          this.isLoadingResults = false;

          return data;
        }


data => {
        this.dataSource.data = data;
      }


result => {
      this.snackbar.open(`Der Verband '${association.name}' wurde gelöscht!`);
      this.dataSource.data = this.dataSource.data.filter(
        obj => obj.id !== association.id
      );
    }


obj => obj.id !== association.id


@Component({
  selector: 'pm-admin-association-list',
  templateUrl: './admin-association-list.component.html',
  styleUrls: ['./admin-association-list.component.scss'],
  animations: [
    trigger('detailExpand', [
      state(
        'collapsed',
        style({ height: '0px', minHeight: '0', display: 'none' })
      ),
      state('expanded', style({ height: '*' })),
      transition(
        'expanded <=> collapsed',
        animate('225ms cubic-bezier(0.4, 0.0, 0.2, 1)')
      )
    ])
  ],
  providers: [AdminAssociationService]
})
export class AdminAssociationListComponent implements OnInit {
  @ViewChild(MatPaginator) paginator: MatPaginator;
  @ViewChild(MatSort) sort: MatSort;

  dataSource: MatTableDataSource<Association>;

  isLoadingResults = true;

  displayedColumns = ['id', 'name'];
  expandedElement: Association | null;

  _associationService: AdminAssociationService;

  constructor(
    private readonly associationService: AdminAssociationService,
    private readonly snackbar: MatSnackBar,
    private readonly navigationBarService: NavigationBarService
  ) {
    this._associationService = associationService;
  }

  ngOnInit(): void {
    this.navigationBarService.setTitle('Verbände (Admin)');
    this.dataSource = new MatTableDataSource();
    this.dataSource.paginator = this.paginator;
    this.dataSource.sort = this.sort;

    of({})
      .pipe(
        switchMap(() => {
          this.isLoadingResults = true;

          return this._associationService.getAssociations();
        }),
        map(data => {
          this.isLoadingResults = false;

          return data;
        })
      )
      .subscribe(data => {
        this.dataSource.data = data;
      });
  }

  applyFilter(filterValue: string): void {
    this.dataSource.filter = filterValue.trim().toLowerCase();

    if (this.dataSource.paginator) {
      this.dataSource.paginator.firstPage();
    }
  }

  onDelete(association: Association): void {
    this.associationService.deleteAssociation(association).subscribe(result => {
      this.snackbar.open(`Der Verband '${association.name}' wurde gelöscht!`);
      this.dataSource.data = this.dataSource.data.filter(
        obj => obj.id !== association.id
      );
    });
  }
}


ngOnInit(): void {
    this.navigationBarService.setTitle('Verbände (Admin)');
    this.dataSource = new MatTableDataSource();
    this.dataSource.paginator = this.paginator;
    this.dataSource.sort = this.sort;

    of({})
      .pipe(
        switchMap(() => {
          this.isLoadingResults = true;

          return this._associationService.getAssociations();
        }),
        map(data => {
          this.isLoadingResults = false;

          return data;
        })
      )
      .subscribe(data => {
        this.dataSource.data = data;
      });
  }


applyFilter(filterValue: string): void {
    this.dataSource.filter = filterValue.trim().toLowerCase();

    if (this.dataSource.paginator) {
      this.dataSource.paginator.firstPage();
    }
  }


onDelete(association: Association): void {
    this.associationService.deleteAssociation(association).subscribe(result => {
      this.snackbar.open(`Der Verband '${association.name}' wurde gelöscht!`);
      this.dataSource.data = this.dataSource.data.filter(
        obj => obj.id !== association.id
      );
    });
  }


@Directive({
  selector: '[baThemeRun]'
})
export class BaThemeRun {

  private _classes: Array<string> = [];
  @HostBinding('class') classesString: string;

  constructor(private _baConfig: BaThemeConfigProvider) {
  }

  public ngOnInit(): void {
    this._assignTheme();
    this._assignMobile();
  }

  private _assignTheme(): void {
    this._addClass(this._baConfig.get().theme.name);
  }

  private _assignMobile(): void {
    if (isMobile()) {
      this._addClass('mobile');
    }
  }

  private _addClass(cls: string) {
    this._classes.push(cls);
    this.classesString = this._classes.join(' ');
  }
}


public ngOnInit(): void {
    this._assignTheme();
    this._assignMobile();
  }


private _assignTheme(): void {
    this._addClass(this._baConfig.get().theme.name);
  }


private _assignMobile(): void {
    if (isMobile()) {
      this._addClass('mobile');
    }
  }


private _addClass(cls: string) {
    this._classes.push(cls);
    this.classesString = this._classes.join(' ');
  }


h => h.test(window.location.host)


/** @title Sidenav with configurable mode */
@Component({
  selector: 'sidenav-mode-example',
  templateUrl: 'sidenav-mode-example.html',
  styleUrls: ['sidenav-mode-example.css'],
})
export class SidenavModeExample {
  mode = new FormControl('over');

  shouldRun = [/(^|\.)plnkr\.co$/, /(^|\.)stackblitz\.io$/].some(h => h.test(window.location.host));
}


export interface ReducerData {
  contents: string[];
}


export type ReduxActionData<T> = {
  type: any;
  payload?: T;
};


export type ReduxAction<T> = (data: T) => ReduxActionData<T>;


@Controller('user')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post('create')
  create(@Body() createUserDto: CreateUserDto): Promise<Users> {
    return this.usersService.create(createUserDto);
  }

  @UseGuards(AuthGuard())
  @Get()
  findAll() {
    return this.usersService.findAll();
  }

  @UseGuards(AuthGuard())
  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(id);
  }

  @UseGuards(AuthGuard())
  @Patch('/update/:id')
  update(@Param('id') id: string, @Body() data: UpdateUserDto): Promise<Users> {
    return this.usersService.update(id, data);
  }

  @UseGuards(AuthGuard())
  @Delete('/delete/:id')
  remove(@Param('id') id: string) {
    return this.usersService.remove(id);
  }

  @UseGuards(AuthGuard())
  @Patch('watchedAnimes/:id')
  watchedAnimes(@AuthUser() user: Users, @Param('id') id: string) {
    return this.usersService.watchedAnimes(user, id);
  }
}


@Post('create')
  create(@Body() createUserDto: CreateUserDto): Promise<Users> {
    return this.usersService.create(createUserDto);
  }


@UseGuards(AuthGuard())
  @Get()
  findAll() {
    return this.usersService.findAll();
  }


@UseGuards(AuthGuard())
  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(id);
  }


@UseGuards(AuthGuard())
  @Patch('/update/:id')
  update(@Param('id') id: string, @Body() data: UpdateUserDto): Promise<Users> {
    return this.usersService.update(id, data);
  }


@UseGuards(AuthGuard())
  @Delete('/delete/:id')
  remove(@Param('id') id: string) {
    return this.usersService.remove(id);
  }


@UseGuards(AuthGuard())
  @Patch('watchedAnimes/:id')
  watchedAnimes(@AuthUser() user: Users, @Param('id') id: string) {
    return this.usersService.watchedAnimes(user, id);
  }


export default class DingTalkNotifyServiceConfig extends BaseComponentConfig {
    constructor() {
        super();
        this.webhook = "";
    }
    webhook: string;
}


() => [User]


() => [Message]


() => Message


@ObjectType({ implements: BaseEntity })
export class Conversation extends BaseEntity {
  @Field(() => String)
  readonly name: string

  @Field(() => String)
  readonly createdById: string

  @Field(() => User)
  readonly createdBy: User

  @Field(() => [String], { nullable: true, defaultValue: [] })
  readonly participantIds?: string[]

  @Field(() => [User], { nullable: true, defaultValue: [] })
  readonly participants?: User[]

  @Field(() => [String], { nullable: true, defaultValue: [] })
  readonly messageIds?: string[]

  @Field(() => [Message], { nullable: true, defaultValue: [] })
  readonly messages?: Message[]
}


@InputType()
export class CreateConversationInput {
  @Field(() => String)
  name: string

  @Field(() => String, { nullable: true })
  createdById?: string

  @Field(() => [String], { nullable: true, defaultValue: [] })
  participantIds?: string[]
}


@InputType()
export class EditConversationInput {
  @Field(() => String, {
    nullable: true,
    description: 'Name of the conversation',
  })
  name?: string

  @Field(() => [String], {
    nullable: true,
    description: 'People who join the conversation',
  })
  participantIds?: string[]

  @Field(() => [String], {
    nullable: true,
    description: 'Messages ID in conversation',
  })
  messageIds?: string[]
}


@ObjectType()
export class ConversationSubscription {
  @Field(() => String)
  conversationId: string

  @Field(() => Message)
  message: Message
}


function ActionsMenu() {
  const { t } = useTranslation();

  return (
    <OverflowMenu light selectorPrimaryFocus={'#editPatientDetails'} size="sm" flipped>
      <OverflowMenuItem
        className={styles.menuItem}
        id="#editPatientDetails"
        itemText={t('editPatientDetails', 'Edit patient details')}>
        {t('editPatientDetails', 'Edit patient details')}
      </OverflowMenuItem>
      <OverflowMenuItem
        className={styles.menuItem}
        id="#setWaitTimeManually"
        itemText={t('setWaitTimeManually', 'Set wait time manually')}>
        {t('setWaitTimeManually', 'Set wait time manually')}
      </OverflowMenuItem>
      <OverflowMenuItem
        className={styles.menuItem}
        id="#endVisit"
        hasDivider
        isDelete
        itemText={t('endVisit', 'End visit')}>
        {t('endVisit', 'End Visit')}
      </OverflowMenuItem>
    </OverflowMenu>
  );
}