		@@ -5,3 +5,3 @@ /**
		export interface IDictionary<T = any> {
		[key: string]: T;
		[key: string]: T;
		}
		@@ -13,3 +13,3 @@ /** Allows the creation of a dictionary structure but specify a set of known keys */
		export interface INumericArray<T = any> {
		[key: number]: T;
		[key: number]: T;
		}
		@@ -41,78 +41,81 @@ /** A function for sorting JS arrays */
		export interface ILambdaErrorResponse<T = any> {
		errorCode?: string \| number;
		errorMessage?: string;
		errorType: "Error";
		errors?: T[];
		stackTrace?: string[];
		errorCode?: string \| number;
		errorMessage?: string;
		errorType: "Error";
		errors?: T[];
		stackTrace?: string[];
		}
		/** A Lambda function called to indicate the SUCCESSFUL end-state of a lambda function */
		export interface ILambdaSuccessCallback<T = IDictionary> {
		(error: null, response: T): void;
		(error: null, response: T): void;
		}
		/** A Lambda function called to indicate a FAILED end-state of a lambda function */
		export interface ILambdaFailureCallback<E = ILambdaErrorResponse> {
		(error: E \| Error): void;
		(error: E \| Error): void;
		}
		/** A Lambda function called to indicate the end-state of a lambda function */
		export declare type LambdaCallback<T = IDictionary, E = ILambdaErrorResponse> = ILambdaSuccessCallback<T> & ILambdaFailureCallback<E>;
		export declare type LambdaCallback<
		T = IDictionary,
		E = ILambdaErrorResponse
		> = ILambdaSuccessCallback<T> & ILambdaFailureCallback<E>;
		/** A Lambda function called that is returning to an API Gateway endpoint */
		export interface IAWSGatewayResponse {
		statusCode: number;
		headers?: IDictionary<string>;
		body?: string;
		error?: string;
		statusCode: number;
		headers?: IDictionary<string>;
		body?: string;
		error?: string;
		}
		export interface IAWSLambaContext {
		/** The default value is true. This property is useful only to modify the default behavior of the callback. By default, the callback will wait until the Node.js runtime event loop is empty before freezing the process and returning the results to the caller. You can set this property to false to request AWS Lambda to freeze the process soon after the callback is called, even if there are events in the event loop. AWS Lambda will freeze the process, any state data and the events in the Node.js event loop (any remaining events in the event loop processed when the Lambda function is called next and if AWS Lambda chooses to use the frozen process). For more information about callback, see Using the Callback Parameter. */
		callbackWaitsForEmptyEventLoop?: boolean;
		/** Name of the Lambda function that is executing. */
		functionName: string;
		/** The Lambda function version that is executing. If an alias is used to invoke the function, then function_version will be the version the alias points to. */
		functionVersion: string;
		/** The ARN used to invoke this function. It can be a function ARN or an alias ARN. An unqualified ARN executes the $LATEST version and aliases execute the function version it is pointing to. */
		invokedFunctionArn: string;
		/** Memory limit, in MB, you configured for the Lambda function. You set the memory limit at the time you create a Lambda function and you can change it later. */
		memoryLimitInMB: string;
		/** AWS request ID associated with the request. This is the ID returned to the client that called the invoke method. Note: if AWS Lambda retries the invocation (for example, in a situation where the Lambda function that is processing Kinesis records throws an exception), the request ID remains the same.*/
		awsRequestId: string;
		/** The name of the CloudWatch log group where you can find logs written by your Lambda function */
		logGroupName: string;
		/** The name of the CloudWatch log group where you can find logs written by your Lambda function. The log stream may or may not change for each invocation of the Lambda function. The value is null if your Lambda function is unable to create a log stream, which can happen if the execution role that grants necessary permissions to the Lambda function does not include permissions for the CloudWatch actions. */
		logStreamName: string;
		/** Information about the Amazon Cognito identity provider when invoked through the AWS Mobile SDK. It can be null. */
		identity?: string;
		/** Information about the client application and device when invoked through the AWS Mobile SDK */
		clientContext?: {
		client: {
		installation_id: string;
		app_title: string;
		app_version_name: string;
		app_version_code: string;
		app_package_name: string;
		};
		Custom: IDictionary;
		env: {
		platform: string;
		platform_version: string;
		make: string;
		model: string;
		locale: string;
		};
		/** The default value is true. This property is useful only to modify the default behavior of the callback. By default, the callback will wait until the Node.js runtime event loop is empty before freezing the process and returning the results to the caller. You can set this property to false to request AWS Lambda to freeze the process soon after the callback is called, even if there are events in the event loop. AWS Lambda will freeze the process, any state data and the events in the Node.js event loop (any remaining events in the event loop processed when the Lambda function is called next and if AWS Lambda chooses to use the frozen process). For more information about callback, see Using the Callback Parameter. */
		callbackWaitsForEmptyEventLoop?: boolean;
		/** Name of the Lambda function that is executing. */
		functionName: string;
		/** The Lambda function version that is executing. If an alias is used to invoke the function, then function_version will be the version the alias points to. */
		functionVersion: string;
		/** The ARN used to invoke this function. It can be a function ARN or an alias ARN. An unqualified ARN executes the $LATEST version and aliases execute the function version it is pointing to. */
		invokedFunctionArn: string;
		/** Memory limit, in MB, you configured for the Lambda function. You set the memory limit at the time you create a Lambda function and you can change it later. */
		memoryLimitInMB: string;
		/** AWS request ID associated with the request. This is the ID returned to the client that called the invoke method. Note: if AWS Lambda retries the invocation (for example, in a situation where the Lambda function that is processing Kinesis records throws an exception), the request ID remains the same.*/
		awsRequestId: string;
		/** The name of the CloudWatch log group where you can find logs written by your Lambda function */
		logGroupName: string;
		/** The name of the CloudWatch log group where you can find logs written by your Lambda function. The log stream may or may not change for each invocation of the Lambda function. The value is null if your Lambda function is unable to create a log stream, which can happen if the execution role that grants necessary permissions to the Lambda function does not include permissions for the CloudWatch actions. */
		logStreamName: string;
		/** Information about the Amazon Cognito identity provider when invoked through the AWS Mobile SDK. It can be null. */
		identity?: string;
		/** Information about the client application and device when invoked through the AWS Mobile SDK */
		clientContext?: {
		client: {
		installation_id: string;
		app_title: string;
		app_version_name: string;
		app_version_code: string;
		app_package_name: string;
		};
		Custom: IDictionary;
		env: {
		platform: string;
		platform_version: string;
		make: string;
		model: string;
		locale: string;
		};
		};
		}
		export interface IAWSGatewayRequest {
		done?: () => void;
		succeed?: () => void;
		fail?: () => void;
		logGroupName?: string;
		logStreamName?: string;
		functionName?: string;
		memoryLimitInMB?: string;
		functionVersion?: string;
		getRemainingTimeInMillis?: string;
		invokeid?: string;
		awsRequestId?: string;
		invokedFunctionArn?: string;
		stage?: "dev" \| "stage" \| "prod";
		parentRequestId?: string;
		done?: () => void;
		succeed?: () => void;
		fail?: () => void;
		logGroupName?: string;
		logStreamName?: string;
		functionName?: string;
		memoryLimitInMB?: string;
		functionVersion?: string;
		getRemainingTimeInMillis?: string;
		invokeid?: string;
		awsRequestId?: string;
		invokedFunctionArn?: string;
		stage?: "dev" \| "stage" \| "prod";
		parentRequestId?: string;
		}
		@@ -122,208 +125,237 @@ /** A decorator signature for a class property */
		/** A decorator signature for a class */
		export declare type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction \| void;
		export declare type ClassDecorator = <TFunction extends Function>(
		target: TFunction
		) => TFunction \| void;
		export interface ReflectionProperty<T> {
		get: () => T;
		set: (value?: any) => void;
		enumerable: boolean;
		configurable: boolean;
		get: () => T;
		set: (value?: any) => void;
		enumerable: boolean;
		configurable: boolean;
		}
		export interface IPackageJsonPerson {
		name: string;
		email?: string;
		url?: string;
		name: string;
		email?: string;
		url?: string;
		}
		/** A typing for the serverless framework's "serverless.yml" file */
		export interface IServerlessYml {
		service: string;
		plugins?: string[];
		package?: {
		individually?: boolean;
		excludeDevDependencies?: boolean;
		browser?: boolean;
		include?: string[];
		exclude?: string[];
		service: string;
		plugins?: string[];
		package?: {
		individually?: boolean;
		excludeDevDependencies?: boolean;
		browser?: boolean;
		include?: string[];
		exclude?: string[];
		};
		provider: {
		name: string;
		runtime: "nodejs6.10" \| "node4" \| "java8" \| "go";
		profile?: string;
		stage?: string;
		region?: string;
		iamRoleStatements: any[];
		stepFunctions?: {
		stateMachines: IStateMachine[];
		};
		provider: {
		name: string;
		runtime: "nodejs6.10" \| "node4" \| "java8" \| "go";
		profile?: string;
		stage?: string;
		region?: string;
		iamRoleStatements: any[];
		stepFunctions?: {
		stateMachines: IStateMachine[];
		};
		};
		};
		}
		export declare type ServerlessEvent = IServerlessEventScheduleShortForm \| IServerlessEventScheduleLongForm;
		export declare type ServerlessEvent =
		\| IServerlessEventScheduleShortForm
		\| IServerlessEventScheduleLongForm;
		export interface IServerlessEventScheduleShortForm {
		/** in the format of rate(10 minutes) or cron(0 12 * * ? ) /
		schedule: string;
		/** in the format of rate(10 minutes) or cron(0 12 * * ? ) /
		schedule: string;
		}
		export interface IServerlessEventScheduleLongForm {
		schedule: {
		/** in the format of rate(10 minutes) or cron(0 12 * * ? ) /
		rate: string;
		enabled?: boolean;
		input: IDictionary;
		inputPath: string;
		};
		schedule: {
		/** in the format of rate(10 minutes) or cron(0 12 * * ? ) /
		rate: string;
		enabled?: boolean;
		input: IDictionary;
		inputPath: string;
		};
		}
		/** of the format of arn:aws:lambda:#{AWS::Region}:#{AWS::AccountId}:function:${self:service}-${opt:stage}-FUNCTION */
		export declare type AwsFunctionArn = string;
		export declare type StepFunctionBuiltinStates = "States.Timeout" \| "States.ALL" \| "States.TaskFailed" \| "States.Permissions";
		export interface IStepFunctionsConfiguration {
		/** defined at the root level of the serverless configuration file */
		stepFunctions: {
		/** A dictionary of */
		stateMachines: IStateMachine;
		};
		export declare type StepFunctionBuiltinStates =
		\| "States.Timeout"
		\| "States.ALL"
		\| "States.TaskFailed"
		\| "States.Permissions";
		export interface IServerlessConfig {
		/** defined at the root level of the serverless configuration file */
		stepFunctions: {
		/** A dictionary of */
		stateMachines: IStateMachine;
		};

		functions;
		}
		export interface IStateMachine {
		[stateMachineName: string]: {
		/** Schedule or HTTP events which trigger the step function */
		events?: [ServerlessEvent];
		/** optionally override the default role used to execute this step-function */
		role?: string;
		/** The definition of the State Machine */
		definition?: {
		/** Prose description of what this Step is about */
		Comment?: string;
		/** A pointer to one of the defined states in the States block which will be the starting point for execution */
		StartAt: keyof StepFunctionStates;
		/** The available states to this state machine */
		States: StepFunctionStates;
		};
		[stateMachineName: string]: {
		/** Schedule or HTTP events which trigger the step function */
		events?: [ServerlessEvent];
		/** optionally override the default role used to execute this step-function */
		role?: string;
		/** The definition of the State Machine */
		definition?: {
		/** Prose description of what this Step is about */
		Comment?: string;
		/** A pointer to one of the defined states in the States block which will be the starting point for execution */
		StartAt: keyof StepFunctionStates;
		/** The available states to this state machine */
		States: StepFunctionStates;
		};
		};
		}
		export declare type StepFunctionStates = IStepFunctionTask & IStepFunctionChoice & IStepFunctionWait & IStepFunctionParallel & IStepFunctionPass & IStepFunctionSucceed;
		export declare type IStepFunctionType = "Task" \| "Wait" \| "Parallel" \| "Choice" \| "Succeed" \| "Pass";
		export declare type StepFunctionStates = IStepFunctionTask &
		IStepFunctionChoice &
		IStepFunctionWait &
		IStepFunctionParallel &
		IStepFunctionPass &
		IStepFunctionSucceed;
		export declare type IStepFunctionType =
		\| "Task"
		\| "Wait"
		\| "Parallel"
		\| "Choice"
		\| "Succeed"
		\| "Pass";
		export interface IStepFunctionBaseState {
		[name: string]: {
		Type: IStepFunctionType;
		};
		[name: string]: {
		Type: IStepFunctionType;
		};
		}
		export interface IStepFunctionTask extends IStepFunctionBaseState {
		[name: string]: {
		Type: "Task";
		/** of the format arn:aws:lambda:#{AWS::Region}:#{AWS::AccountId}:function:${self:service}-${opt:stage}-FUNCTION_NAME */
		Resource: AwsFunctionArn;
		Next?: string;
		End?: true;
		Retry?: [{
		ErrorEquals: string[];
		IntervalSeconds: number;
		BackoffRate: number;
		MaxAttemps: number;
		}];
		Catch?: [{
		ErrorEquals: string[];
		Next: string;
		}];
		};
		[name: string]: {
		Type: "Task";
		/** of the format arn:aws:lambda:#{AWS::Region}:#{AWS::AccountId}:function:${self:service}-${opt:stage}-FUNCTION_NAME */
		Resource: AwsFunctionArn;
		Next?: string;
		End?: true;
		Retry?: [
		{
		ErrorEquals: string[];
		IntervalSeconds: number;
		BackoffRate: number;
		MaxAttemps: number;
		}
		];
		Catch?: [
		{
		ErrorEquals: string[];
		Next: string;
		}
		];
		};
		}
		export interface IStepFunctionChoice extends IStepFunctionBaseState {
		[name: string]: {
		Type: "Choice";
		Choices: [{
		/** points to the specific area of context which is being evaluated in the choice */
		Variable: string;
		/** compare the value passed in -- and scoped by "Variable" -- to be numerically equal to a stated number */
		NumericEquals?: number;
		/** the next state to move to when completed with this one */
		Next?: string;
		/** the step-function should stop at this step */
		End?: boolean;
		}];
		};
		[name: string]: {
		Type: "Choice";
		Choices: [
		{
		/** points to the specific area of context which is being evaluated in the choice */
		Variable: string;
		/** compare the value passed in -- and scoped by "Variable" -- to be numerically equal to a stated number */
		NumericEquals?: number;
		/** the next state to move to when completed with this one */
		Next?: string;
		/** the step-function should stop at this step */
		End?: boolean;
		}
		];
		};
		}
		export interface IStepFunctionWait extends IStepFunctionBaseState {
		[name: string]: {
		Type: "Wait";
		Seconds: number;
		Next: AwsFunctionArn;
		};
		[name: string]: {
		Type: "Wait";
		Seconds: number;
		Next: AwsFunctionArn;
		};
		}
		export interface IStepFunctionSucceed extends IStepFunctionBaseState {
		[name: string]: {
		Type: "Succeed";
		};
		[name: string]: {
		Type: "Succeed";
		};
		}
		export interface IStepFunctionPass extends IStepFunctionBaseState {
		[name: string]: {
		Type: "Pass";
		Result?: any;
		ResultPath?: string;
		Next: string;
		};
		[name: string]: {
		Type: "Pass";
		Result?: any;
		ResultPath?: string;
		Next: string;
		};
		}
		export interface IStepFunctionParallel extends IStepFunctionBaseState {
		[name: string]: {
		Type: "Parallel";
		Branches: [{
		StartAt: string;
		States: StepFunctionStates;
		}];
		Next?: string;
		End?: true;
		};
		[name: string]: {
		Type: "Parallel";
		Branches: [
		{
		StartAt: string;
		States: StepFunctionStates;
		}
		];
		Next?: string;
		End?: true;
		};
		}
		export interface IPackageJson {
		name: string;
		version: string;
		description?: string;
		keywords?: string[];
		homepage?: url;
		bugs?: {
		url: string;
		email: string;
		};
		/** the full list of SPDX license IDs (https://spdx.org/licenses/) */
		license?: string;
		author?: IPackageJsonPerson;
		contributors?: IPackageJsonPerson[];
		/**
		* The optional "files" field is an array of file patterns that describes the entries to be included when your package is installed as a dependency. If the files array is omitted, everything except automatically-excluded files will be included in your publish. If you name a folder in the array, then it will also include the files inside that folder (unless they would be ignored by another rule in this section.).
		*/
		files?: string[];
		/**
		* The main field is a module ID that is the primary entry point to your program. That is, if your package is named foo, and a user installs it, and then does require("foo"), then your main module's exports object will be returned.
		*/
		main?: string;
		/**
		* A lot of packages have one or more executable files that they'd like to install into the PATH. npm makes this pretty easy (in fact, it uses this feature to install the "npm" executable.)
		*/
		bin?: any;
		man?: string \| string[];
		directories?: {
		lib: string;
		bin: string;
		man: string;
		doc: string;
		example: string;
		test: string;
		};
		/** Specify the place where your code lives */
		repository?: string;
		/** The "scripts" property is a dictionary containing script commands that are run at various times in the lifecycle of your package. The key is the lifecycle event, and the value is the command to run at that point. */
		scripts?: IDictionary<string>;
		/** A "config" object can be used to set configuration parameters used in package scripts that persist across upgrades. */
		config?: {
		name: string;
		version: string;
		description?: string;
		keywords?: string[];
		homepage?: url;
		bugs?: {
		url: string;
		email: string;
		};
		/** the full list of SPDX license IDs (https://spdx.org/licenses/) */
		license?: string;
		author?: IPackageJsonPerson;
		contributors?: IPackageJsonPerson[];
		/**
		* The optional "files" field is an array of file patterns that describes the entries to be included when your package is installed as a dependency. If the files array is omitted, everything except automatically-excluded files will be included in your publish. If you name a folder in the array, then it will also include the files inside that folder (unless they would be ignored by another rule in this section.).
		*/
		files?: string[];
		/**
		* The main field is a module ID that is the primary entry point to your program. That is, if your package is named foo, and a user installs it, and then does require("foo"), then your main module's exports object will be returned.
		*/
		main?: string;
		/**
		* A lot of packages have one or more executable files that they'd like to install into the PATH. npm makes this pretty easy (in fact, it uses this feature to install the "npm" executable.)
		*/
		bin?: any;
		man?: string \| string[];
		directories?: {
		lib: string;
		bin: string;
		man: string;
		doc: string;
		example: string;
		test: string;
		};
		/** Specify the place where your code lives */
		repository?: string;
		/** The "scripts" property is a dictionary containing script commands that are run at various times in the lifecycle of your package. The key is the lifecycle event, and the value is the command to run at that point. */
		scripts?: IDictionary<string>;
		/** A "config" object can be used to set configuration parameters used in package scripts that persist across upgrades. */
		config?: {
		name: string;
		config: IDictionary<string>;
		};
		dependencies?: IDictionary<string>;
		/** If someone is planning on downloading and using your module in their program, then they probably don't want or need to download and build the external test or documentation framework that you use. */
		devDependencies?: IDictionary<string>;
		/** In some cases, you want to express the compatibility of your package with a host tool or library, while not necessarily doing a require of this host. This is usually referred to as a plugin. Notably, your module may be exposing a specific interface, expected and specified by the host documentation. */
		peerDependencies?: IDictionary<string>;
		/** This defines an array of package names that will be bundled when publishing the package. */
		bundledDependencies?: string[];
		/** If a dependency can be used, but you would like npm to proceed if it cannot be found or fails to install, then you may put it in the optionalDependencies object. This is a map of package name to version or url, just like the dependencies object. The difference is that build failures do not cause installation to fail. */
		optionalDependencies?: IDictionary<string>;
		/** You can specify the version of node that your stuff works on */
		engines?: IDictionary<string>;
		/** You can specify which operating systems your module will run on */
		os?: string[];
		cpu?: string[];
		config: IDictionary<string>;
		};
		dependencies?: IDictionary<string>;
		/** If someone is planning on downloading and using your module in their program, then they probably don't want or need to download and build the external test or documentation framework that you use. */
		devDependencies?: IDictionary<string>;
		/** In some cases, you want to express the compatibility of your package with a host tool or library, while not necessarily doing a require of this host. This is usually referred to as a plugin. Notably, your module may be exposing a specific interface, expected and specified by the host documentation. */
		peerDependencies?: IDictionary<string>;
		/** This defines an array of package names that will be bundled when publishing the package. */
		bundledDependencies?: string[];
		/** If a dependency can be used, but you would like npm to proceed if it cannot be found or fails to install, then you may put it in the optionalDependencies object. This is a map of package name to version or url, just like the dependencies object. The difference is that build failures do not cause installation to fail. */
		optionalDependencies?: IDictionary<string>;
		/** You can specify the version of node that your stuff works on */
		engines?: IDictionary<string>;
		/** You can specify which operating systems your module will run on */
		os?: string[];
		cpu?: string[];
		}

package.json

		{
		"name": "common-types",
		"version": "1.6.17",
		"version": "1.6.18",
		"description": "Common types not included in Typescript",
		"repository": "https://github.com/lifegadget/common-types",
		"main": "lib/common-types.js",
		"types": "lib/common-types.d.ts",
		"main": "lib/index.js",
		"types": "lib/index.d.ts",
		"files": ["lib/common-types.js", "lib/common-types.d.ts", "lib/common-types.js.map"],
		@@ -9,0 +9,0 @@ "scripts": {

common-types - npm Package Compare versions

Improved metrics

Worsened metrics