import { F as FromSchemaUnvalidated, S as Schema, a as FromSchema } from './base.schema.types-BApIn9jr.js';

type ContextType = string;
type ContextId = string;
type ContextData = Record<string, unknown>;
/**
 * Context value can be either a simple string identifier or a rich object with additional data
 *
 * @example
 * // Simple string value
 * "org-acme"
 *
 * @example
 * // Rich object with optional data
 * {
 *   id: "org-acme",
 *   data: { name: "Acme Corp", plan: "enterprise" }
 * }
 */
type ContextValue = string | {
    id: ContextId;
    data?: ContextData;
};
/**
 * Context payload represents the raw context data provided by users when triggering workflows.
 * It's a flexible structure that maps context types to their values.
 *
 * This is the input format that gets processed and resolved into ContextResolved.
 *
 * @example
 * // Single context with string value
 * { tenant: "org-acme" }
 *
 * @example
 * // Multiple contexts with string values
 * { tenant: "org-acme", app: "jira", user: "john-doe" }
 *
 * @example
 * // Context with rich object containing additional data
 * {
 *   tenant: {
 *     id: "org-acme",
 *     data: { name: "Acme Corp", plan: "enterprise" }
 *   }
 * }
 *
 * @example
 * // Mixed context values (string and object)
 * {
 *   tenant: { id: "org-acme", data: { name: "Acme Corp" } },
 *   app: "jira",
 *   user: "john-doe"
 * }
 */
type ContextPayload = Partial<Record<ContextType, ContextValue>>;
/**
 * Resolved contexts represent the normalized, fully-processed context data used internally
 * throughout the application and framework. This ensures consistent structure regardless
 * of the input format in ContextPayload.
 *
 * All contexts are normalized to have both an `id` and `data` field, even if the original
 * payload only provided a string value (in which case `data` will be an empty object).
 *
 * This type is used to:
 * - Pass context data between services without exposing full entity details
 * - Ensure consistent context structure in workflow execution
 * - Provide type safety for context access in templates and conditions
 *
 * @example
 * // Resolved from payload: { tenant: "org-acme", app: "jira" }
 * {
 *   tenant: {
 *     id: "org-acme",
 *     data: {} // Empty data since only ID was provided
 *   },
 *   app: {
 *     id: "jira",
 *     data: {} // Empty data since only ID was provided
 *   }
 * }
 *
 * @example
 * // Resolved from payload with rich data
 * {
 *   tenant: {
 *     id: "org-acme",
 *     data: { name: "Acme Corp", plan: "enterprise", region: "us-east" }
 *   },
 *   app: {
 *     id: "jira",
 *     data: { version: "8.0", environment: "production" }
 *   }
 * }
 */
type ContextResolved = Record<ContextType, {
    id: ContextId;
    data: ContextData;
}>;

declare enum ChannelStepEnum {
    EMAIL = "email",
    SMS = "sms",
    PUSH = "push",
    CHAT = "chat",
    IN_APP = "in_app"
}
declare enum ActionStepEnum {
    DIGEST = "digest",
    DELAY = "delay",
    THROTTLE = "throttle",
    CUSTOM = "custom",
    HTTP_REQUEST = "http_request"
}

/**
 * A type that represents either `A` or `B`. Shared properties retain their
 * types and unique properties are marked as optional.
 */
type Either<A, B> = Partial<A> & Partial<B> & (A | B);
/**
 * A type that represents a value that may be a promise or a regular value.
 */
type Awaitable<T> = T | Promise<T>;
/**
 * A type that represents a type that is a prettified version of the original type.
 * The prettified type has all generics removed from intellisense and displays a flat object.
 */
type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
/**
 * Mark properties of T as optional if Condition is true
 */
type ConditionalPartial<T extends Obj, Condition extends boolean> = Condition extends true ? Partial<T> : T;
/**
 * Same as Nullable except without `null`.
 */
type Optional<T> = T | undefined;
/**
 * Types that can be used to index native JavaScript types, (Object, Array, etc.).
 */
type IndexSignature = string | number | symbol;
/**
 * An object of any index-able type to avoid conflicts between `{}`, `Record`, `object`, etc.
 */
type Obj<O extends Record<IndexSignature, unknown> | object = Record<IndexSignature, unknown> | object> = {
    [K in keyof O as K extends never ? never : K]: K extends never ? never : O[K] extends never ? never : O[K];
} & Omit<O, never>;
/**
 * Any type that is indexable using `string`, `number`, or `symbol`.
 */
type Indexable<ValueTypes = unknown> = {
    [K: IndexSignature]: ValueTypes;
} | Obj;
/**
 * Picks only the optional properties from a type, removing the required ones.
 * Optionally, recurses through nested objects if `DEEP` is true.
 */
type PickOptional<T, DEEP extends boolean = true> = {
    [K in keyof T as undefined extends T[K] ? K : never]: DEEP extends false ? T[K] : T[K] extends Optional<Indexable> ? PickOptional<T[K], DEEP> : T[K];
};
/**
 * Picks only the required fields out of a type, removing the optional ones.
 * Optionally, recurses through nested objects if `DEEP` is true.
 */
type PickRequired<T, DEEP extends boolean = true> = {
    [K in keyof T as K extends keyof PickOptional<T, DEEP> ? never : K]: T[K] extends Indexable ? PickRequired<T[K], DEEP> : T[K];
};
/**
 * Picks only the required keys out of a type, removing the optional ones.
 * Optionally, recurses through nested objects if `DEEP` is true.
 */
type PickRequiredKeys<T, DEEP extends boolean = true> = keyof PickRequired<T, DEEP>;
/**
 * Picks only the optional keys out of a type, removing the required ones.
 * Optionally, recurses through nested objects if `DEEP` is true.
 */
type PickOptionalKeys<T, DEEP extends boolean = true> = keyof PickOptional<T, DEEP>;
/**
 * Recursively make all properties of type `T` optional.
 */
type DeepPartial<T> = T extends object ? {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;
/**
 * Recursively make all properties of type `T` required.
 */
type DeepRequired<T> = T extends object ? {
    [P in keyof T]-?: DeepRequired<T[P]>;
} : T;

declare const providerSchemas: {
    readonly chat: {
        readonly 'chat-webhook': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly discord: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly getstream: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'grafana-on-call': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly mattermost: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly msteams: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'rocket-chat': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly ryver: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly slack: {
            output: {
                readonly type: "object";
                readonly properties: {
                    readonly webhookUrl: {
                        readonly type: "string";
                        readonly format: "uri";
                    };
                    readonly text: {
                        readonly type: "string";
                    };
                    readonly blocks: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "object";
                            readonly properties: {
                                readonly type: {
                                    readonly enum: readonly ["image", "context", "actions", "divider", "section", "input", "file", "header", "video", "rich_text"];
                                };
                            };
                            readonly required: readonly ["type"];
                            readonly additionalProperties: true;
                        };
                    };
                };
                readonly additionalProperties: true;
            };
        };
        readonly 'whatsapp-business': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly zulip: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
    };
    readonly sms: {
        readonly 'africas-talking': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'azure-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly bandwidth: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'brevo-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'bulk-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'burst-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly clickatell: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly clicksend: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'eazy-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly firetext: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'forty-six-elks': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'generic-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly gupshup: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'infobip-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'isend-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly kannel: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly maqsam: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly messagebird: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly mobishastra: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly nexmo: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'novu-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: false;
            };
        };
        readonly plivo: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'ring-central': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly sendchamp: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly simpletexting: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly sms77: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'sms-central': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly smsmode: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly sns: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly telnyx: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly termii: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly twilio: {
            output: {
                readonly type: "object";
                readonly properties: {
                    readonly to: {
                        readonly type: "string";
                        readonly pattern: "^\\+[1-9]\\d{1,14}$";
                        readonly description: "The recipient's phone number in [E.164](https://www.twilio.com/docs/glossary/what-e164) format (for SMS/MMS) or [channel address](https://www.twilio.com/docs/messaging/channels), e.g. `whatsapp:+15552229999`.";
                    };
                    readonly statusCallback: {
                        readonly type: "string";
                        readonly format: "uri";
                        readonly description: "The URL of the endpoint to which Twilio sends [Message status callback requests](https://www.twilio.com/docs/sms/api/message-resource#twilios-request-to-the-statuscallback-url). URL must contain a valid hostname and underscores are not allowed. If you include this parameter with the `messagingServiceSid`, Twilio uses this URL instead of the Status Callback URL of the [Messaging Service](https://www.twilio.com/docs/messaging/api/service-resource). ";
                    };
                    readonly applicationSid: {
                        readonly type: "string";
                        readonly minLength: 34;
                        readonly maxLength: 34;
                        readonly pattern: "^AP[0-9a-fA-F]{32}$";
                        readonly description: "The SID of the associated [TwiML Application](https://www.twilio.com/docs/usage/api/applications). [Message status callback requests](https://www.twilio.com/docs/sms/api/message-resource#twilios-request-to-the-statuscallback-url) are sent to the TwiML App's `statusCallback` URL. Note that the `statusCallback` parameter of a request takes priority over the `applicationSid` parameter; if both are included `applicationSid` is ignored.";
                    };
                    readonly maxPrice: {
                        readonly type: "number";
                        readonly description: "[OBSOLETE] This parameter will no longer have any effect as of 2024-06-03.";
                    };
                    readonly provideFeedback: {
                        readonly type: "boolean";
                        readonly description: "Boolean indicating whether or not you intend to provide delivery confirmation feedback to Twilio (used in conjunction with the [Message Feedback subresource](https://www.twilio.com/docs/sms/api/message-feedback-resource)). Default value is `false`.";
                    };
                    readonly attempt: {
                        readonly type: "integer";
                        readonly description: "Total number of attempts made (including this request) to send the message regardless of the provider used";
                    };
                    readonly validityPeriod: {
                        readonly type: "integer";
                        readonly description: "The maximum length in seconds that the Message can remain in Twilio's outgoing message queue. If a queued Message exceeds the `validityPeriod`, the Message is not sent. Accepted values are integers from `1` to `36000`. Default value is `36000`. A `validityPeriod` greater than `5` is recommended. [Learn more about the validity period](https://www.twilio.com/blog/take-more-control-of-outbound-messages-using-validity-period-html)";
                    };
                    readonly forceDelivery: {
                        readonly type: "boolean";
                        readonly description: "Reserved";
                    };
                    readonly contentRetention: {
                        readonly type: "string";
                        readonly enum: readonly ["retain", "discard"];
                        readonly description: "Determines if the message content can be stored or redacted based on privacy settings";
                    };
                    readonly addressRetention: {
                        readonly type: "string";
                        readonly enum: readonly ["retain", "obfuscate"];
                        readonly description: "Determines if the address can be stored or obfuscated based on privacy settings";
                    };
                    readonly smartEncoded: {
                        readonly type: "boolean";
                        readonly description: "Whether to detect Unicode characters that have a similar GSM-7 character and replace them. Can be: `true` or `false`.";
                    };
                    readonly persistentAction: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                        readonly description: "Rich actions for non-SMS/MMS channels. Used for [sending location in WhatsApp messages](https://www.twilio.com/docs/whatsapp/message-features#location-messages-with-whatsapp).";
                    };
                    readonly shortenUrls: {
                        readonly type: "boolean";
                        readonly description: "For Messaging Services with [Link Shortening configured](https://www.twilio.com/docs/messaging/features/link-shortening) only: A Boolean indicating whether or not Twilio should shorten links in the `body` of the Message. Default value is `false`. If `true`, the `messagingServiceSid` parameter must also be provided.";
                    };
                    readonly scheduleType: {
                        readonly type: "string";
                        readonly enum: readonly ["fixed"];
                        readonly description: "For Messaging Services only: Include this parameter with a value of `fixed` in conjunction with the `sendAt` parameter in order to [schedule a Message](https://www.twilio.com/docs/messaging/features/message-scheduling).";
                    };
                    readonly sendAt: {
                        readonly type: "string";
                        readonly format: "date-time";
                        readonly description: "The time that Twilio will send the message. Must be in ISO 8601 format.";
                    };
                    readonly sendAsMms: {
                        readonly type: "boolean";
                        readonly description: "If set to `true`, Twilio delivers the message as a single MMS message, regardless of the presence of media.";
                    };
                    readonly contentVariables: {
                        readonly type: "string";
                        readonly description: "For [Content Editor/API](https://www.twilio.com/docs/content) only: Key-value pairs of [Template variables](https://www.twilio.com/docs/content/using-variables-with-content-api) and their substitution values. `contentSid` parameter must also be provided. If values are not defined in the `contentVariables` parameter, the [Template's default placeholder values](https://www.twilio.com/docs/content/content-api-resources#create-templates) are used.";
                    };
                    readonly riskCheck: {
                        readonly type: "string";
                        readonly enum: readonly ["enable", "disable"];
                        readonly description: "Include this parameter with a value of `disable` to skip any kind of risk check on the respective message request.";
                    };
                    readonly from: {
                        readonly type: "string";
                        readonly pattern: "^\\+[1-9]\\d{1,14}$";
                        readonly description: "The sender's Twilio phone number (in [E.164](https://en.wikipedia.org/wiki/E.164) format), [alphanumeric sender ID](https://www.twilio.com/docs/sms/quickstart), [Wireless SIM](https://www.twilio.com/docs/iot/wireless/programmable-wireless-send-machine-machine-sms-commands), [short code](https://www.twilio.com/en-us/messaging/channels/sms/short-codes), or [channel address](https://www.twilio.com/docs/messaging/channels) (e.g., `whatsapp:+15554449999`). The value of the `from` parameter must be a sender that is hosted within Twilio and belongs to the Account creating the Message. If you are using `messagingServiceSid`, this parameter can be empty (Twilio assigns a `from` value from the Messaging Service's Sender Pool) or you can provide a specific sender from your Sender Pool.";
                    };
                    readonly messagingServiceSid: {
                        readonly type: "string";
                        readonly minLength: 34;
                        readonly maxLength: 34;
                        readonly pattern: "^MG[0-9a-fA-F]{32}$";
                        readonly description: "The SID of the [Messaging Service](https://www.twilio.com/docs/messaging/services) you want to associate with the Message. When this parameter is provided and the `from` parameter is omitted, Twilio selects the optimal sender from the Messaging Service's Sender Pool. You may also provide a `from` parameter if you want to use a specific Sender from the Sender Pool.";
                    };
                    readonly body: {
                        readonly type: "string";
                        readonly description: "The text content of the outgoing message. Can be up to 1,600 characters in length. SMS only: If the `body` contains more than 160 [GSM-7](https://www.twilio.com/docs/glossary/what-is-gsm-7-character-encoding) characters (or 70 [UCS-2](https://www.twilio.com/docs/glossary/what-is-ucs-2-character-encoding) characters), the message is segmented and charged accordingly. For long `body` text, consider using the [sendAsMms parameter](https://www.twilio.com/blog/mms-for-long-text-messages).";
                    };
                    readonly mediaUrl: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                            readonly format: "uri";
                        };
                        readonly description: "The URL of media to include in the Message content. `jpeg`, `jpg`, `gif`, and `png` file types are fully supported by Twilio and content is formatted for delivery on destination devices. The media size limit is 5 MB for supported file types (`jpeg`, `jpg`, `png`, `gif`) and 500 KB for [other types](https://www.twilio.com/docs/messaging/guides/accepted-mime-types) of accepted media. To send more than one image in the message, provide multiple `mediaUrl` parameters in the POST request. You can include up to ten `mediaUrl` parameters per message. [International](https://support.twilio.com/hc/en-us/articles/223179808-Sending-and-receiving-MMS-messages) and [carrier](https://support.twilio.com/hc/en-us/articles/223133707-Is-MMS-supported-for-all-carriers-in-US-and-Canada-) limits apply.";
                    };
                    readonly contentSid: {
                        readonly type: "string";
                        readonly minLength: 34;
                        readonly maxLength: 34;
                        readonly pattern: "^HX[0-9a-fA-F]{32}$";
                        readonly description: "For [Content Editor/API](https://www.twilio.com/docs/content) only: The SID of the Content Template to be used with the Message, e.g., `HXXXXXXXXXXXXXXXXXXXXXXXXXXXXX`. If this parameter is not provided, a Content Template is not used. Find the SID in the Console on the Content Editor page. For Content API users, the SID is found in Twilio's response when [creating the Template](https://www.twilio.com/docs/content/content-api-resources#create-templates) or by [fetching your Templates](https://www.twilio.com/docs/content/content-api-resources#fetch-all-content-resources).";
                    };
                };
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'afro-message': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly unifonic: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly imedia: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly sinch: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'isendpro-sms': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
    };
    readonly email: {
        readonly braze: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly clickatell: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly nodemailer: {
            output: {
                readonly type: "object";
                readonly properties: {
                    readonly from: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly address: {
                                    readonly type: "string";
                                };
                                readonly name: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }];
                    };
                    readonly sender: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly address: {
                                    readonly type: "string";
                                };
                                readonly name: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }];
                    };
                    readonly to: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly address: {
                                    readonly type: "string";
                                };
                                readonly name: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly address: {
                                        readonly type: "string";
                                    };
                                    readonly name: {
                                        readonly type: "string";
                                    };
                                };
                                readonly additionalProperties: true;
                            };
                        }];
                    };
                    readonly cc: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly address: {
                                    readonly type: "string";
                                };
                                readonly name: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly address: {
                                        readonly type: "string";
                                    };
                                    readonly name: {
                                        readonly type: "string";
                                    };
                                };
                                readonly additionalProperties: true;
                            };
                        }];
                    };
                    readonly bcc: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly address: {
                                    readonly type: "string";
                                };
                                readonly name: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly address: {
                                        readonly type: "string";
                                    };
                                    readonly name: {
                                        readonly type: "string";
                                    };
                                };
                                readonly additionalProperties: true;
                            };
                        }];
                    };
                    readonly replyTo: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly address: {
                                    readonly type: "string";
                                };
                                readonly name: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly address: {
                                        readonly type: "string";
                                    };
                                    readonly name: {
                                        readonly type: "string";
                                    };
                                };
                                readonly additionalProperties: true;
                            };
                        }];
                    };
                    readonly inReplyTo: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly address: {
                                    readonly type: "string";
                                };
                                readonly name: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }];
                    };
                    readonly references: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                        }];
                    };
                    readonly subject: {
                        readonly type: "string";
                    };
                    readonly text: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly content: {
                                    readonly type: "string";
                                };
                                readonly path: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }];
                    };
                    readonly html: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly content: {
                                    readonly type: "string";
                                };
                                readonly path: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }];
                    };
                    readonly watchHtml: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly content: {
                                    readonly type: "string";
                                };
                                readonly path: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        }];
                    };
                    readonly amp: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly content: {
                                    readonly type: "string";
                                };
                                readonly path: {
                                    readonly type: "string";
                                };
                                readonly href: {
                                    readonly type: "string";
                                };
                                readonly encoding: {
                                    readonly type: "string";
                                };
                                readonly contentType: {
                                    readonly type: "string";
                                };
                                readonly raw: {
                                    readonly anyOf: readonly [{
                                        readonly type: "string";
                                    }, {
                                        readonly type: "object";
                                        readonly properties: {
                                            readonly content: {
                                                readonly type: "string";
                                            };
                                            readonly path: {
                                                readonly type: "string";
                                            };
                                        };
                                        readonly additionalProperties: true;
                                    }];
                                };
                            };
                        }];
                    };
                    readonly icalEvent: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly content: {
                                    readonly type: "string";
                                };
                                readonly path: {
                                    readonly type: "string";
                                };
                                readonly method: {
                                    readonly type: "string";
                                };
                                readonly filename: {
                                    readonly anyOf: readonly [{
                                        readonly type: "string";
                                    }, {
                                        readonly type: "boolean";
                                    }];
                                };
                                readonly href: {
                                    readonly type: "string";
                                };
                                readonly encoding: {
                                    readonly type: "string";
                                };
                            };
                        }];
                    };
                    readonly headers: {
                        readonly anyOf: readonly [{
                            readonly type: "object";
                            readonly additionalProperties: true;
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "object";
                                readonly additionalProperties: true;
                            };
                        }];
                    };
                    readonly list: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                        }];
                    };
                    readonly attachments: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "object";
                            readonly properties: {
                                readonly content: {
                                    readonly type: "string";
                                };
                                readonly path: {
                                    readonly type: "string";
                                };
                            };
                            readonly additionalProperties: true;
                        };
                    };
                };
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly emailjs: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'email-webhook': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'infobip-email': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly mailersend: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly mailgun: {
            output: {
                readonly type: "object";
                readonly properties: {
                    readonly to: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                        }];
                        readonly description: "Email address of the recipient(s). Example: \"Bob bob@host.com\". You can use commas to separate multiple recipients (e.g.: \"test@example.com,test@example.com\" or [\"test@example.com\", \"test@example.com\"]).";
                    };
                    readonly from: {
                        readonly type: "string";
                    };
                    readonly subject: {
                        readonly type: "string";
                        readonly description: "Subject of the message.";
                    };
                    readonly text: {
                        readonly type: "string";
                        readonly description: "Text version of the message.";
                    };
                    readonly html: {
                        readonly type: "string";
                        readonly description: "HTML version of the message.";
                    };
                    readonly message: {
                        readonly type: "string";
                        readonly description: "MIME string of the message. Make sure to use multipart/form-data to send this as a file upload.";
                    };
                    readonly cc: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                        }];
                        readonly description: "Same as To but for carbon copy";
                    };
                    readonly bcc: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                        }];
                        readonly description: "Same as To but for blind carbon copy";
                    };
                    readonly ampHtml: {
                        readonly type: "string";
                    };
                    readonly tVersion: {
                        readonly type: "string";
                    };
                    readonly tText: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                            readonly enum: readonly ["yes", "no"];
                        }, {
                            readonly type: "boolean";
                        }];
                    };
                    readonly oTag: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                        }];
                        readonly description: "Tag string. See Tagging for more information.";
                    };
                    readonly oDkim: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                            readonly enum: readonly ["yes", "no"];
                        }, {
                            readonly type: "boolean";
                        }];
                        readonly description: "Enables/disabled DKIM signatures on per-message basis. Pass yes or no";
                    };
                    readonly oDeliverytime: {
                        readonly type: "string";
                        readonly description: "Desired time of delivery. See Date Format. Note: Messages can be scheduled for a maximum of 3 days in the future.";
                    };
                    readonly oDeliverytimeOptimizePeriod: {
                        readonly type: "string";
                    };
                    readonly oTimeZoneLocalize: {
                        readonly type: "string";
                    };
                    readonly oTestmode: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                            readonly enum: readonly ["yes", "no"];
                        }, {
                            readonly type: "boolean";
                        }];
                        readonly description: "Enables sending in test mode. Pass yes if needed. See Sending in Test Mode";
                    };
                    readonly oTracking: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                            readonly enum: readonly ["yes", "no"];
                        }, {
                            readonly type: "boolean";
                        }];
                        readonly description: "Toggles tracking on a per-message basis, see Tracking Messages for details. Pass yes or no.";
                    };
                    readonly oTrackingClicks: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                            readonly enum: readonly ["yes", "no", "htmlonly"];
                        }, {
                            readonly type: "boolean";
                        }];
                        readonly description: "Toggles clicks tracking on a per-message basis. Has higher priority than domain-level setting. Pass yes, no or htmlonly.";
                    };
                    readonly oTrackingOpens: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                            readonly enum: readonly ["yes", "no"];
                        }, {
                            readonly type: "boolean";
                        }];
                        readonly description: "Toggles opens tracking on a per-message basis. Has higher priority than domain-level setting. Pass yes or no.";
                    };
                    readonly oRequireTls: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                            readonly enum: readonly ["yes", "no"];
                        }, {
                            readonly type: "boolean";
                        }];
                    };
                    readonly oSkipVerification: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                            readonly enum: readonly ["yes", "no"];
                        }, {
                            readonly type: "boolean";
                        }];
                    };
                    readonly recipientVariables: {
                        readonly type: "string";
                    };
                };
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly mailjet: {
            output: {
                readonly type: "object";
                readonly properties: {
                    readonly from: {
                        type: "object";
                        properties: {
                            name: {
                                type: "string";
                            };
                            email: {
                                type: "string";
                            };
                        };
                        description: string;
                        required: string[];
                        additionalProperties: true;
                    };
                    readonly sender: {
                        type: "object";
                        properties: {
                            name: {
                                type: "string";
                            };
                            email: {
                                type: "string";
                            };
                        };
                        description: string;
                        required: string[];
                        additionalProperties: true;
                    };
                    readonly to: {
                        readonly type: "array";
                        readonly items: {
                            type: "object";
                            properties: {
                                name: {
                                    type: "string";
                                };
                                email: {
                                    type: "string";
                                };
                            };
                            description: string;
                            required: string[];
                            additionalProperties: true;
                        };
                    };
                    readonly cc: {
                        readonly type: "array";
                        readonly items: {
                            type: "object";
                            properties: {
                                name: {
                                    type: "string";
                                };
                                email: {
                                    type: "string";
                                };
                            };
                            description: string;
                            required: string[];
                            additionalProperties: true;
                        };
                    };
                    readonly bcc: {
                        readonly type: "array";
                        readonly items: {
                            type: "object";
                            properties: {
                                name: {
                                    type: "string";
                                };
                                email: {
                                    type: "string";
                                };
                            };
                            description: string;
                            required: string[];
                            additionalProperties: true;
                        };
                    };
                    readonly replyTo: {
                        type: "object";
                        properties: {
                            name: {
                                type: "string";
                            };
                            email: {
                                type: "string";
                            };
                        };
                        description: string;
                        required: string[];
                        additionalProperties: true;
                    };
                    readonly subject: {
                        readonly type: "string";
                    };
                    readonly textPart: {
                        readonly type: "string";
                        readonly description: "Content of the message, sent in Text and/or HTML format. At least one of these content types needs to be specified. When the HTML part is the only part provided, Mailjet will not generate a Text-part from the HTML version. The property can't be set when you use TemplateID";
                    };
                    readonly htmlPart: {
                        readonly type: "string";
                        readonly description: "Content of the message, sent in Text and/or HTML format. At least one of these content types needs to be specified. When the HTML part is the only part provided, Mailjet will not generate a Text-part from the HTML version. The property can't be set when you use TemplateID";
                    };
                    readonly templateId: {
                        readonly type: "number";
                        readonly description: "an ID for a template that is previously created and stored in Mailjet's system. It is mandatory when From and TextPart and/or HtmlPart are not provided. ";
                    };
                    readonly templateLanguage: {
                        readonly type: "boolean";
                    };
                    readonly templateErrorReporting: {
                        type: "object";
                        properties: {
                            name: {
                                type: "string";
                            };
                            email: {
                                type: "string";
                            };
                        };
                        description: string;
                        required: string[];
                        additionalProperties: true;
                    };
                    readonly templateErrorDeliver: {
                        readonly type: "boolean";
                    };
                    readonly attachments: {
                        readonly type: "array";
                        readonly items: {
                            type: "object";
                            properties: {
                                contentType: {
                                    type: "string";
                                };
                                filename: {
                                    type: "string";
                                };
                                base64Content: {
                                    type: "string";
                                };
                            };
                            required: string[];
                            additionalProperties: true;
                        };
                    };
                    readonly inlineAttachments: {
                        readonly type: "array";
                        readonly items: {
                            type: "object";
                            properties: {
                                filename: {
                                    type: "string";
                                };
                                contentType: {
                                    type: "string";
                                };
                                contentId: {
                                    type: "string";
                                };
                                base64Content: {
                                    type: "string";
                                };
                            };
                            required: string[];
                            additionalProperties: true;
                        };
                    };
                    readonly priority: {
                        readonly type: "number";
                    };
                    readonly customCampaign: {
                        readonly type: "string";
                    };
                    readonly deduplicateCampaign: {
                        readonly type: "boolean";
                    };
                    readonly trackOpens: {
                        readonly type: "string";
                        readonly enum: readonly ["account_default", "disabled", "enabled"];
                    };
                    readonly trackClicks: {
                        readonly type: "string";
                        readonly enum: readonly ["account_default", "disabled", "enabled"];
                    };
                    readonly customId: {
                        readonly type: "string";
                    };
                    readonly eventPayload: {
                        readonly type: "string";
                    };
                    readonly urlTags: {
                        readonly type: "string";
                    };
                    readonly headers: {
                        readonly type: "object";
                        readonly additionalProperties: true;
                    };
                    readonly variables: {
                        readonly type: "object";
                        readonly additionalProperties: true;
                    };
                };
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly mailtrap: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly mandrill: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly netcore: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'novu-email': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: false;
            };
        };
        readonly outlook365: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly plunk: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly postmark: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly resend: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly sendgrid: {
            output: {
                readonly type: "object";
                readonly properties: {
                    readonly personalizations: {
                        readonly type: "array";
                        readonly description: "An array of messages and their metadata. Each object within personalizations can be thought of as an envelope - it defines who should receive an individual message and how that message should be handled. See our [Personalizations documentation](https://sendgrid.com/docs/for-developers/sending-email/personalizations/) for examples.";
                        readonly uniqueItems: false;
                        readonly maxItems: 1000;
                        readonly items: {
                            readonly type: "object";
                            readonly properties: {
                                readonly from: {
                                    readonly title: "From Email Object";
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly email: {
                                            readonly type: "string";
                                            readonly format: "email";
                                            readonly description: "The 'From' email address used to deliver the message. This address should be a verified sender in your Twilio SendGrid account.";
                                        };
                                        readonly name: {
                                            readonly type: "string";
                                            readonly description: "A name or title associated with the sending email address.";
                                        };
                                    };
                                    readonly required: readonly ["email"];
                                };
                                readonly to: {
                                    readonly title: "To Email Array";
                                    readonly type: "array";
                                    readonly items: {
                                        readonly type: "object";
                                        readonly properties: {
                                            readonly email: {
                                                readonly type: "string";
                                                readonly format: "email";
                                                readonly description: "The intended recipient's email address.";
                                            };
                                            readonly name: {
                                                readonly type: "string";
                                                readonly description: "The intended recipient's name.";
                                            };
                                        };
                                        readonly required: readonly ["email"];
                                    };
                                };
                                readonly cc: {
                                    readonly type: "array";
                                    readonly description: "An array of recipients who will receive a copy of your email. Each object in this array must contain the recipient's email address. Each object in the array may optionally contain the recipient's name.";
                                    readonly maxItems: 1000;
                                    readonly items: {
                                        readonly title: "CC BCC Email Object";
                                        readonly type: "object";
                                        readonly properties: {
                                            readonly email: {
                                                readonly type: "string";
                                                readonly format: "email";
                                                readonly description: "The intended recipient's email address.";
                                            };
                                            readonly name: {
                                                readonly type: "string";
                                                readonly description: "The intended recipient's name.";
                                            };
                                        };
                                        readonly required: readonly ["email"];
                                    };
                                };
                                readonly bcc: {
                                    readonly type: "array";
                                    readonly description: "An array of recipients who will receive a blind carbon copy of your email. Each object in this array must contain the recipient's email address. Each object in the array may optionally contain the recipient's name.";
                                    readonly maxItems: 1000;
                                    readonly items: {
                                        readonly title: "CC BCC Email Object";
                                        readonly type: "object";
                                        readonly properties: {
                                            readonly email: {
                                                readonly type: "string";
                                                readonly format: "email";
                                                readonly description: "The intended recipient's email address.";
                                            };
                                            readonly name: {
                                                readonly type: "string";
                                                readonly description: "The intended recipient's name.";
                                            };
                                        };
                                        readonly required: readonly ["email"];
                                    };
                                };
                                readonly subject: {
                                    readonly type: "string";
                                    readonly description: "The subject of your email. See character length requirements according to [RFC 2822](http://stackoverflow.com/questions/1592291/what-is-the-email-subject-length-limit#answer-1592310).";
                                    readonly minLength: 1;
                                };
                                readonly headers: {
                                    readonly type: "object";
                                    readonly description: "A collection of JSON key/value pairs allowing you to specify handling instructions for your email. You may not overwrite the following headers: `x-sg-id`, `x-sg-eid`, `received`, `dkim-signature`, `Content-Type`, `Content-Transfer-Encoding`, `To`, `From`, `Subject`, `Reply-To`, `CC`, `BCC`";
                                };
                                readonly substitutions: {
                                    readonly type: "object";
                                    readonly description: "Substitutions allow you to insert data without using Dynamic Transactional Templates. This field should **not** be used in combination with a Dynamic Transactional Template, which can be identified by a `templateId` starting with `d-`. This field is a collection of key/value pairs following the pattern \"substitutionTag\":\"value to substitute\". The key/value pairs must be strings. These substitutions will apply to the text and html content of the body of your email, in addition to the `subject` and `reply-to` parameters. The total collective size of your substitutions may not exceed 10,000 bytes per personalization object.";
                                    readonly maxProperties: 10000;
                                };
                                readonly dynamicTemplateData: {
                                    readonly type: "object";
                                    readonly description: "Dynamic template data is available using Handlebars syntax in Dynamic Transactional Templates. This field should be used in combination with a Dynamic Transactional Template, which can be identified by a `templateId` starting with `d-`. This field is a collection of key/value pairs following the pattern \"variable_name\":\"value to insert\".";
                                };
                                readonly customArgs: {
                                    readonly type: "object";
                                    readonly description: "Values that are specific to this personalization that will be carried along with the email and its activity data. Substitutions will not be made on custom arguments, so any string that is entered into this parameter will be assumed to be the custom argument that you would like to be used. This field may not exceed 10,000 bytes.";
                                    readonly maxProperties: 10000;
                                };
                                readonly sendAt: {
                                    readonly type: "integer";
                                    readonly description: "A unix timestamp allowing you to specify when your email should be delivered. Scheduling delivery more than 72 hours in advance is forbidden.";
                                };
                            };
                            readonly required: readonly ["to"];
                        };
                    };
                    readonly from: {
                        readonly title: "From Email Object";
                        readonly type: "object";
                        readonly properties: {
                            readonly email: {
                                readonly type: "string";
                                readonly format: "email";
                                readonly description: "The 'From' email address used to deliver the message. This address should be a verified sender in your Twilio SendGrid account.";
                            };
                            readonly name: {
                                readonly type: "string";
                                readonly description: "A name or title associated with the sending email address.";
                            };
                        };
                        readonly required: readonly ["email"];
                    };
                    readonly replyTo: {
                        readonly title: "Reply_to Email Object";
                        readonly type: "object";
                        readonly properties: {
                            readonly email: {
                                readonly type: "string";
                                readonly format: "email";
                                readonly description: "The email address where any replies or bounces will be returned.";
                            };
                            readonly name: {
                                readonly type: "string";
                                readonly description: "A name or title associated with the `replyTo` email address.";
                            };
                        };
                        readonly required: readonly ["email"];
                    };
                    readonly replyToList: {
                        readonly type: "array";
                        readonly description: "An array of recipients who will receive replies and/or bounces. Each object in this array must contain the recipient's email address. Each object in the array may optionally contain the recipient's name. You can either choose to use “replyTo” field or “replyToList” but not both.";
                        readonly uniqueItems: true;
                        readonly maxItems: 1000;
                        readonly items: {
                            readonly type: "object";
                            readonly properties: {
                                readonly email: {
                                    readonly type: "string";
                                    readonly description: "The email address where any replies or bounces will be returned.";
                                    readonly format: "email";
                                };
                                readonly name: {
                                    readonly type: "string";
                                    readonly description: "A name or title associated with the `replyToList` email address.";
                                };
                            };
                            readonly required: readonly ["email"];
                        };
                    };
                    readonly subject: {
                        readonly type: "string";
                        readonly description: "The global or 'message level' subject of your email. This may be overridden by subject lines set in personalizations.";
                        readonly minLength: 1;
                    };
                    readonly content: {
                        readonly type: "array";
                        readonly description: "An array where you can specify the content of your email. You can include multiple [MIME types](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types) of content, but you must specify at least one MIME type. To include more than one MIME type, add another object to the array containing the `type` and `value` parameters.";
                        readonly items: {
                            readonly type: "object";
                            readonly properties: {
                                readonly type: {
                                    readonly type: "string";
                                    readonly description: "The MIME type of the content you are including in your email (e.g., `“text/plain”` or `“text/html”`).";
                                    readonly minLength: 1;
                                };
                                readonly value: {
                                    readonly type: "string";
                                    readonly description: "The actual content of the specified MIME type that you are including in your email.";
                                    readonly minLength: 1;
                                };
                            };
                            readonly required: readonly ["type", "value"];
                        };
                    };
                    readonly attachments: {
                        readonly type: "array";
                        readonly description: "An array of objects where you can specify any attachments you want to include.";
                        readonly items: {
                            readonly type: "object";
                            readonly properties: {
                                readonly content: {
                                    readonly type: "string";
                                    readonly description: "The Base64 encoded content of the attachment.";
                                    readonly minLength: 1;
                                };
                                readonly type: {
                                    readonly type: "string";
                                    readonly description: "The MIME type of the content you are attaching (e.g., `“text/plain”` or `“text/html”`).";
                                    readonly minLength: 1;
                                };
                                readonly filename: {
                                    readonly type: "string";
                                    readonly description: "The attachment's filename.";
                                };
                                readonly disposition: {
                                    readonly type: "string";
                                    readonly default: "attachment";
                                    readonly description: "The attachment's content-disposition, specifying how you would like the attachment to be displayed. For example, `“inline”` results in the attached file are displayed automatically within the message while `“attachment”` results in the attached file require some action to be taken before it is displayed, such as opening or downloading the file.";
                                    readonly enum: readonly ["inline", "attachment"];
                                };
                                readonly contentId: {
                                    readonly type: "string";
                                    readonly description: "The attachment's content ID. This is used when the disposition is set to `“inline”` and the attachment is an image, allowing the file to be displayed within the body of your email.";
                                };
                            };
                            readonly required: readonly ["content", "filename"];
                        };
                    };
                    readonly templateId: {
                        readonly type: "string";
                        readonly description: "An email template ID. A template that contains a subject and content — either text or html — will override any subject and content values specified at the personalizations or message level.";
                    };
                    readonly headers: {
                        readonly description: "An object containing key/value pairs of header names and the value to substitute for them. The key/value pairs must be strings. You must ensure these are properly encoded if they contain unicode characters. These headers cannot be one of the reserved headers.";
                        readonly type: "object";
                    };
                    readonly categories: {
                        readonly type: "array";
                        readonly description: "An array of category names for this message. Each category name may not exceed 255 characters. ";
                        readonly uniqueItems: true;
                        readonly maxItems: 10;
                        readonly items: {
                            readonly type: "string";
                            readonly maxLength: 255;
                        };
                    };
                    readonly customArgs: {
                        readonly description: "Values that are specific to the entire send that will be carried along with the email and its activity data.  Key/value pairs must be strings. Substitutions will not be made on custom arguments, so any string that is entered into this parameter will be assumed to be the custom argument that you would like to be used. This parameter is overridden by `customArgs` set at the personalizations level. Total `customArgs` size may not exceed 10,000 bytes.";
                        readonly type: "string";
                    };
                    readonly sendAt: {
                        readonly type: "integer";
                        readonly description: "A unix timestamp allowing you to specify when you want your email to be delivered. This may be overridden by the `sendAt` parameter set at the personalizations level. Delivery cannot be scheduled more than 72 hours in advance. If you have the flexibility, it's better to schedule mail for off-peak times. Most emails are scheduled and sent at the top of the hour or half hour. Scheduling email to avoid peak times — for example, scheduling at 10:53 — can result in lower deferral rates due to the reduced traffic during off-peak times.";
                    };
                    readonly batchId: {
                        readonly type: "string";
                        readonly description: "An ID representing a batch of emails to be sent at the same time. Including a `batchId` in your request allows you include this email in that batch. It also enables you to cancel or pause the delivery of that batch. For more information, see the [Cancel Scheduled Sends API](https://sendgrid.com/docs/api-reference/).";
                    };
                    readonly asm: {
                        readonly type: "object";
                        readonly description: "An object allowing you to specify how to handle unsubscribes.";
                        readonly properties: {
                            readonly groupId: {
                                readonly type: "integer";
                                readonly description: "The unsubscribe group to associate with this email.";
                            };
                            readonly groupsToDisplay: {
                                readonly type: "array";
                                readonly description: "An array containing the unsubscribe groups that you would like to be displayed on the unsubscribe preferences page.";
                                readonly maxItems: 25;
                                readonly items: {
                                    readonly type: "integer";
                                };
                            };
                        };
                        readonly required: readonly ["groupId"];
                    };
                    readonly ipPoolName: {
                        readonly type: "string";
                        readonly description: "The IP Pool that you would like to send this email from.";
                        readonly minLength: 2;
                        readonly maxLength: 64;
                    };
                    readonly mailSettings: {
                        readonly type: "object";
                        readonly description: "A collection of different mail settings that you can use to specify how you would like this email to be handled.";
                        readonly properties: {
                            readonly bypassListManagement: {
                                readonly type: "object";
                                readonly description: "Allows you to bypass all unsubscribe groups and suppressions to ensure that the email is delivered to every single recipient. This should only be used in emergencies when it is absolutely necessary that every recipient receives your email. This filter cannot be combined with any other bypass filters. See our [documentation](https://sendgrid.com/docs/ui/sending-email/index-suppressions/#bypass-suppressions) for more about bypass filters.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                };
                            };
                            readonly bypassSpamManagement: {
                                readonly type: "object";
                                readonly description: "Allows you to bypass the spam report list to ensure that the email is delivered to recipients. Bounce and unsubscribe lists will still be checked; addresses on these other lists will not receive the message. This filter cannot be combined with the `bypassListManagement` filter. See our [documentation](https://sendgrid.com/docs/ui/sending-email/index-suppressions/#bypass-suppressions) for more about bypass filters.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                };
                            };
                            readonly bypassBounceManagement: {
                                readonly type: "object";
                                readonly description: "Allows you to bypass the bounce list to ensure that the email is delivered to recipients. Spam report and unsubscribe lists will still be checked; addresses on these other lists will not receive the message. This filter cannot be combined with the `bypassListManagement` filter. See our [documentation](https://sendgrid.com/docs/ui/sending-email/index-suppressions/#bypass-suppressions) for more about bypass filters.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                };
                            };
                            readonly bypassUnsubscribeManagement: {
                                readonly type: "object";
                                readonly description: "Allows you to bypass the global unsubscribe list to ensure that the email is delivered to recipients. Bounce and spam report lists will still be checked; addresses on these other lists will not receive the message. This filter applies only to global unsubscribes and will not bypass group unsubscribes. This filter cannot be combined with the `bypassListManagement` filter. See our [documentation](https://sendgrid.com/docs/ui/sending-email/index-suppressions/#bypass-suppressions) for more about bypass filters.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                };
                            };
                            readonly footer: {
                                readonly type: "object";
                                readonly description: "The default footer that you would like included on every email.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                    readonly text: {
                                        readonly type: "string";
                                        readonly description: "The plain text content of your footer.";
                                    };
                                    readonly html: {
                                        readonly type: "string";
                                        readonly description: "The HTML content of your footer.";
                                    };
                                };
                            };
                            readonly sandboxMode: {
                                readonly type: "object";
                                readonly description: "Sandbox Mode allows you to send a test email to ensure that your request body is valid and formatted correctly.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                };
                            };
                        };
                    };
                    readonly trackingSettings: {
                        readonly type: "object";
                        readonly description: "Settings to determine how you would like to track the metrics of how your recipients interact with your email.";
                        readonly properties: {
                            readonly clickTracking: {
                                readonly type: "object";
                                readonly description: "Allows you to track if a recipient clicked a link in your email.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                    readonly enableText: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting should be included in the `text/plain` portion of your email.";
                                    };
                                };
                            };
                            readonly openTracking: {
                                readonly type: "object";
                                readonly description: "Allows you to track if the email was opened by including a single pixel image in the body of the content. When the pixel is loaded, Twilio SendGrid can log that the email was opened.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                    readonly substitutionTag: {
                                        readonly type: "string";
                                        readonly description: "Allows you to specify a substitution tag that you can insert in the body of your email at a location that you desire. This tag will be replaced by the open tracking pixel.";
                                    };
                                };
                            };
                            readonly subscriptionTracking: {
                                readonly type: "object";
                                readonly description: "Allows you to insert a subscription management link at the bottom of the text and HTML bodies of your email. If you would like to specify the location of the link within your email, you may use the `substitutionTag`.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                    readonly text: {
                                        readonly type: "string";
                                        readonly description: "Text to be appended to the email with the subscription tracking link. You may control where the link is by using the tag <% %>";
                                    };
                                    readonly html: {
                                        readonly type: "string";
                                        readonly description: "HTML to be appended to the email with the subscription tracking link. You may control where the link is by using the tag <% %>";
                                    };
                                    readonly substitutionTag: {
                                        readonly type: "string";
                                        readonly description: "A tag that will be replaced with the unsubscribe URL. for example: `[unsubscribe_url]`. If this parameter is used, it will override both the `text` and `html` parameters. The URL of the link will be placed at the substitution tag’s location with no additional formatting.";
                                    };
                                };
                            };
                            readonly ganalytics: {
                                readonly type: "object";
                                readonly description: "Allows you to enable tracking provided by Google Analytics.";
                                readonly properties: {
                                    readonly enable: {
                                        readonly type: "boolean";
                                        readonly description: "Indicates if this setting is enabled.";
                                    };
                                    readonly utmSource: {
                                        readonly type: "string";
                                        readonly description: "Name of the referrer source. (e.g. Google, SomeDomain.com, or Marketing Email)";
                                    };
                                    readonly utmMedium: {
                                        readonly type: "string";
                                        readonly description: "Name of the marketing medium. (e.g. Email)";
                                    };
                                    readonly utmTerm: {
                                        readonly type: "string";
                                        readonly description: "Used to identify any paid keywords.";
                                    };
                                    readonly utmContent: {
                                        readonly type: "string";
                                        readonly description: "Used to differentiate your campaign from advertisements.";
                                    };
                                    readonly utmCampaign: {
                                        readonly type: "string";
                                        readonly description: "The name of the campaign.";
                                    };
                                };
                            };
                        };
                    };
                };
                readonly required: readonly [];
                readonly additionalProperties: false;
            };
        };
        readonly sendinblue: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly ses: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly sparkpost: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
    };
    readonly push: {
        readonly apns: {
            output: {
                readonly type: "object";
                readonly properties: {
                    readonly topic: {
                        readonly type: "string";
                        readonly description: "The destination topic for the notification.";
                    };
                    readonly id: {
                        readonly type: "string";
                        readonly description: "A UUID to identify the notification with APNS. If an id is not supplied, APNS will generate one automatically. If an error occurs the response will contain the id. This property populates the apns-id header.";
                    };
                    readonly expiry: {
                        readonly type: "number";
                        readonly description: "A UNIX timestamp when the notification should expire. If the notification cannot be delivered to the device, APNS will retry until it expires. An expiry of 0 indicates that the notification expires immediately, therefore no retries will be attempted.";
                    };
                    readonly priority: {
                        readonly type: "number";
                        readonly description: "Provide one of the following values:\n\n10 - The push notification is sent to the device immediately. (Default)\nThe push notification must trigger an alert, sound, or badge on the device. It is an error to use this priority for a push notification that contains only the content-available key.\n\n5 - The push message is sent at a time that conserves power on the device receiving it.";
                    };
                    readonly collapseId: {
                        readonly type: "string";
                    };
                    readonly pushType: {
                        readonly type: "string";
                        readonly enum: readonly ["background", "alert", "voip"];
                        readonly description: "The type of the notification. The value of this header is alert or background. Specify alert when the delivery of your notification displays an alert, plays a sound, or badges your app's icon. Specify background for silent notifications that do not interact with the user.\n\nThe value of this header must accurately reflect the contents of your notification's payload. If there is a mismatch, or if the header is missing on required systems, APNs may delay the delivery of the notification or drop it altogether.";
                    };
                    readonly threadId: {
                        readonly type: "string";
                    };
                    readonly payload: {
                        readonly type: "object";
                        readonly additionalProperties: true;
                    };
                    readonly aps: {
                        readonly type: "object";
                        readonly additionalProperties: true;
                        readonly properties: {
                            readonly badge: {
                                readonly type: "number";
                            };
                            readonly sound: {
                                anyOf: ({
                                    type: "string";
                                    additionalProperties?: undefined;
                                    properties?: undefined;
                                    required?: undefined;
                                } | {
                                    type: "object";
                                    additionalProperties: true;
                                    properties: {
                                        name: {
                                            type: "string";
                                        };
                                        volume: {
                                            type: "number";
                                        };
                                        critical: {
                                            type: "number";
                                        };
                                    };
                                    required: string[];
                                })[];
                            };
                            readonly category: {
                                readonly type: "string";
                            };
                            readonly contentAvailable: {
                                readonly type: "number";
                            };
                            readonly launchImage: {
                                readonly type: "number";
                            };
                            readonly mutableContent: {
                                readonly type: "number";
                            };
                            readonly urlArgs: {
                                readonly type: "array";
                                readonly items: {
                                    readonly type: "string";
                                };
                            };
                        };
                    };
                    readonly rawPayload: {
                        readonly type: "object";
                        readonly additionalProperties: true;
                    };
                    readonly badge: {
                        readonly type: "number";
                    };
                    readonly sound: {
                        anyOf: ({
                            type: "string";
                            additionalProperties?: undefined;
                            properties?: undefined;
                            required?: undefined;
                        } | {
                            type: "object";
                            additionalProperties: true;
                            properties: {
                                name: {
                                    type: "string";
                                };
                                volume: {
                                    type: "number";
                                };
                                critical: {
                                    type: "number";
                                };
                            };
                            required: string[];
                        })[];
                    };
                    readonly alert: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly additionalProperties: true;
                            readonly properties: {
                                readonly title: {
                                    readonly type: "string";
                                };
                                readonly body: {
                                    readonly type: "string";
                                };
                                readonly subtitle: {
                                    readonly type: "string";
                                };
                                readonly titleLocKey: {
                                    readonly type: "string";
                                };
                                readonly titleLocArgs: {
                                    readonly type: "array";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly actionLocKey: {
                                    readonly type: "string";
                                };
                                readonly locKey: {
                                    readonly type: "string";
                                };
                                readonly locArgs: {
                                    readonly type: "array";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly launchImage: {
                                    readonly type: "string";
                                };
                            };
                            readonly required: readonly ["body"];
                        }];
                    };
                    readonly contentAvailable: {
                        readonly type: "boolean";
                    };
                    readonly mutableContent: {
                        readonly type: "boolean";
                    };
                    readonly mdm: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "object";
                            readonly additionalProperties: true;
                        }];
                    };
                    readonly urlArgs: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                };
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly expo: {
            output: {
                readonly type: "object";
                readonly properties: {
                    readonly to: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                        }];
                        readonly description: "An Expo push token or an array of Expo push tokens specifying the recipient(s) of this message.";
                    };
                    readonly data: {
                        readonly type: "object";
                        readonly additionalProperties: true;
                        readonly description: "A JSON object delivered to your app. It may be up to about 4KiB; the total notification payload sent to Apple and Google must be at most 4KiB or else you will get a \"Message Too Big\" error.";
                    };
                    readonly title: {
                        readonly type: "string";
                        readonly description: "The title to display in the notification. Often displayed above the notification body.";
                    };
                    readonly subtitle: {
                        readonly type: "string";
                        readonly description: "The subtitle to display in the notification below the title.";
                    };
                    readonly body: {
                        readonly type: "string";
                        readonly description: "The message to display in the notification.";
                    };
                    readonly sound: {
                        readonly anyOf: readonly [{
                            readonly type: "string";
                        }, {
                            readonly type: "null";
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly name: {
                                    readonly anyOf: readonly [{
                                        readonly type: "string";
                                        readonly enum: readonly ["default"];
                                    }, {
                                        readonly type: "null";
                                    }];
                                };
                                readonly volume: {
                                    readonly type: "number";
                                };
                                readonly critical: {
                                    readonly type: "boolean";
                                };
                            };
                            readonly additionalProperties: true;
                        }];
                        readonly description: "Play a sound when the recipient receives this notification. Specify default to play the device's default notification sound, or omit this field to play no sound. Custom sounds are not supported.";
                    };
                    readonly ttl: {
                        readonly type: "number";
                        readonly description: "Time to Live: the number of seconds for which the message may be kept around for redelivery if it hasn't been delivered yet. Defaults to undefined to use the respective defaults of each provider (2419200 (4 weeks) for Android/FCM and 0 for iOS/APNs).";
                    };
                    readonly expiration: {
                        readonly type: "number";
                        readonly description: "Timestamp since the Unix epoch specifying when the message expires. Same effect as ttl (ttl takes precedence over expiration).";
                    };
                    readonly priority: {
                        readonly type: "string";
                        readonly enum: readonly ["default", "normal", "high"];
                        readonly description: "The delivery priority of the message. Specify default or omit this field to use the default priority on each platform (\"normal\" on Android and \"high\" on iOS).";
                    };
                    readonly badge: {
                        readonly type: "number";
                        readonly description: "Number to display in the badge on the app icon. Specify zero to clear the badge.";
                    };
                    readonly channelId: {
                        readonly type: "string";
                        readonly description: "ID of the Notification Channel through which to display this notification. If an ID is specified but the corresponding channel does not exist on the device (that has not yet been created by your app), the notification will not be displayed to the user.";
                    };
                    readonly categoryId: {
                        readonly type: "string";
                        readonly description: "ID of the notification category that this notification is associated with.";
                    };
                    readonly mutableContent: {
                        readonly type: "boolean";
                        readonly description: "Specifies whether this notification can be intercepted by the client app. In Expo Go, this defaults to true, and if you change that to false, you may experience issues. In standalone and bare apps, this defaults to false.";
                    };
                };
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly fcm: {
            output: {
                readonly type: "object";
                readonly properties: {
                    readonly to: {
                        readonly description: "This parameter specifies the recipient of a message.\nThe value must be a registration token, notification key, or topic. Do not set this field when sending to multiple topics. See **condition**.\n";
                        readonly type: "string";
                    };
                    readonly registrationIds: {
                        readonly description: "This parameter specifies a list of devices (registration tokens, or IDs) receiving a multicast message. It must contain at least 1 and at most 1000 registration tokens.\nUse this parameter only for multicast messaging, not for single recipients. Multicast messages (sending to more than 1 registration tokens) are allowed using HTTP JSON format only.\n";
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                    readonly condition: {
                        readonly description: "This parameter specifies a logical expression of conditions that determine the message target.\nSupported condition: Topic, formatted as yourTopic in topics. This value is case-insensitive.\nSupported operators: &&, ||. Maximum two operators per topic message supported.\n";
                        readonly type: "string";
                    };
                    readonly notificationKey: {
                        readonly description: "This parameter is deprecated. Instead, use **to** to specify message recipients. For more information on how to send messages to multiple devices using **to**, see [Device Group Messaging](https://firebase.google.com/docs/cloud-messaging/notifications).\n";
                        readonly type: "string";
                    };
                    readonly collapseKey: {
                        readonly description: "This parameter identifies a group of messages (e.g., with ```\"collapseKey\": \"Updates Available\"```) that can be collapsed, so that only the last message gets sent when delivery can be resumed. This is intended to avoid sending too many of the same messages when the device comes back online or becomes active (see **delayWhileIdle**).\nNote that there is no guarantee of the order in which messages get sent.\nNote: A maximum of 4 different collapse keys is allowed at any given time. This means a FCM connection server can simultaneously store 4 different send-to-sync messages per client app. If you exceed this number, there is no guarantee which 4 collapse keys the FCM connection server will keep.\n";
                        readonly type: "string";
                    };
                    readonly priority: {
                        readonly description: "Sets the priority of the message. Valid values are normal and high. On iOS, these correspond to APNs priorities 5 and 10.\nBy default, messages are sent with normal priority. Normal priority optimizes the client app's battery consumption and should be used unless immediate delivery is required. For messages with normal priority, the app may receive the message with unspecified delay.\nWhen a message is sent with high priority, it is sent immediately, and the app can wake a sleeping device and open a network connection to your server.For more information, see [Setting the priority of a message](https://firebase.google.com/docs/cloud-messaging/concept-options#setting-the-priority-of-a-message).\n";
                        readonly type: "string";
                        readonly enum: readonly ["normal", "high"];
                    };
                    readonly contentAvailable: {
                        readonly description: "On iOS, use this field to represent **content-available** in the APNS payload. When a notification or message is sent and this is set to ```true```, an inactive client app is awoken. On Android, data messages wake the app by default. On Chrome, currently not supported.\n";
                        readonly type: "boolean";
                    };
                    readonly mutableContent: {
                        readonly description: "Currently for iOS 10+ devices only. On iOS, use this field to represent mutable-content in the APNS payload. When a notification is sent and this is set to true, the content of the notification can be modified before it is displayed, using a [Notification Service app extension](https://developer.apple.com/reference/usernotifications/unnotificationserviceextension). This parameter will be ignored for Android and web.\n";
                        readonly type: "boolean";
                    };
                    readonly delayWhileIdle: {
                        readonly description: "When this parameter is set to ```true```, it indicates that the message should not be sent until the device becomes active.\nThe default value is ```false```.\n";
                        readonly type: "boolean";
                    };
                    readonly timeToLive: {
                        readonly description: "This parameter specifies how long (in seconds) the message should be kept in FCM storage if the device is offline. The maximum time to live supported is 4 weeks, and the default value is 4 weeks. For more information, see [Setting the lifespan of a message](https://firebase.google.com/docs/cloud-messaging/concept-options#ttl).\n";
                        readonly type: "number";
                    };
                    readonly restrictedPackageName: {
                        readonly description: "This parameter specifies the package name of the application where the registration tokens must match in order to receive the message.\n";
                        readonly type: "string";
                    };
                    readonly dryRun: {
                        readonly description: "This parameter, when set to ```true```, allows developers to test a request without actually sending a message.\nThe default value is ```false```.\n";
                        readonly type: "boolean";
                    };
                    readonly data: {
                        readonly description: "This parameter specifies the custom key-value pairs of the message's payload.\nFor example, with ```\"data\":{\"score\":\"3x1\"}```:\nOn iOS, if the message is sent via APNS, it represents the custom data fields. If it is sent via FCM connection server, it would be represented as key value dictionary in ```AppDelegate application:didReceiveRemoteNotification:```.\nOn Android, this would result in an intent extra named **score** with the string value **3x1**.\nThe key should not be a reserved word (\"from\" or any word starting with \"google\" or \"gcm\"). Do not use any of the words defined in this table (such as **collapseKey**).\n";
                        readonly type: "object";
                        readonly additionalProperties: {
                            readonly type: "string";
                        };
                    };
                    readonly notification: {
                        readonly description: "Notification payload. For more information about notification message and data message options, see [Payload](https://firebase.google.com/docs/cloud-messaging/concept-options#notifications_and_data_messages).\n";
                        readonly type: "object";
                        readonly properties: {
                            readonly title: {
                                readonly description: "Indicates notification title. This field is not visible on iOS phones and tablets. Field is required for android.";
                                readonly type: "string";
                            };
                            readonly body: {
                                readonly description: "Indicates notification body text.";
                                readonly type: "string";
                            };
                            readonly icon: {
                                readonly description: "android: Indicates notification icon. Sets value to **myicon** for drawable resource **myicon**.";
                                readonly type: "string";
                            };
                            readonly sound: {
                                readonly description: "Indicates a sound to play when the device receives a notification.\n* iOS: Sound files can be in the main bundle of the client app or in the Library/Sounds folder of the app's data container. See the [iOS Developer Library](https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/IPhoneOSClientImp.html#//apple_ref/doc/uid/TP40008194-CH103-SW6) for more information).\n* android: Supports default or the filename of a sound resource bundled in the app. Sound files must reside in /res/raw/.\n";
                                readonly type: "string";
                            };
                            readonly badge: {
                                readonly description: "iOS: Indicates the badge on the client app home icon.";
                                readonly type: "string";
                            };
                            readonly tag: {
                                readonly description: "android: Indicates whether each notification results in a new entry in the notification drawer.\nIf not set, each request creates a new notification.\nIf set, and a notification with the same tag is already being shown, the new notification replaces the existing one in the notification drawer.\n";
                                readonly type: "string";
                            };
                            readonly color: {
                                readonly description: "android: Indicates color of the icon, expressed in #rrggbb format";
                                readonly type: "string";
                            };
                            readonly clickAction: {
                                readonly description: "Indicates the action associated with a user click on the notification.\n* iOS:  Corresponds to category in the APNs payload.\n* android: When this is set, an activity with a matching intent filter is launched when user clicks the notification.\n";
                                readonly type: "string";
                            };
                            readonly bodyLocKey: {
                                readonly description: "Indicates the key to the body string for localization.\n* iOS: Corresponds to \"loc-key\" in the APNs payload.\n* android: Use the key in the app's string resources when populating this value.\n";
                                readonly type: "string";
                            };
                            readonly bodyLocArgs: {
                                readonly description: "Indicates the string value to replace format specifiers in the body string for localization.\n* iOS: Corresponds to \"loc-args\" in the APNs payload.\n* android:  See [Formatting and Styling](https://developer.android.com/guide/topics/resources/string-resource.html#FormattingAndStyling).\n";
                                readonly type: "string";
                            };
                            readonly titleLocKey: {
                                readonly description: "Indicates the key to the title string for localization.\n* iOS: Corresponds to \"title-loc-key\" in the APNs payload.\n* android:  Use the key in the app's string resources when populating this value.\n";
                                readonly type: "string";
                            };
                            readonly titleLocArgs: {
                                readonly description: "Indicates the string value to replace format specifiers in the title string for localization.\n* iOS: Corresponds to \"title-loc-args\" in the APNs payload.\n* android: See [Formatting strings](https://developer.android.com/guide/topics/resources/string-resource.html#FormattingAndStyling).\n";
                                readonly type: "string";
                            };
                        };
                    };
                };
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'one-signal': {
            output: {
                readonly allOf: [{
                    readonly allOf: readonly [{
                        readonly anyOf: readonly [{
                            readonly type: "object";
                            readonly properties: {
                                readonly includedSegments: {
                                    readonly type: "array";
                                    readonly description: "The segment names you want to target. Users in these segments will receive a notification. This targeting parameter is only compatible with excludedSegments.\nExample: [\"Active Users\", \"Inactive Users\"]\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly excludedSegments: {
                                    readonly type: "array";
                                    readonly description: "Segment that will be excluded when sending. Users in these segments will not receive a notification, even if they were included in includedSegments. This targeting parameter is only compatible with includedSegments.\nExample: [\"Active Users\", \"Inactive Users\"]\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                            };
                        }, {
                            readonly type: "object";
                            readonly properties: {
                                readonly includePlayerIds: {
                                    readonly type: "array";
                                    readonly description: "Specific playerids to send your notification to. _Does not require API Auth Key.\nDo not combine with other targeting parameters. Not compatible with any other targeting parameters.\nExample: [\"1dd608f2-c6a1-11e3-851d-000c2940e62c\"]\nLimit of 2,000 entries per REST API call\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                    readonly nullable: true;
                                };
                                readonly includeExternalUserIds: {
                                    readonly type: "array";
                                    readonly description: "Target specific devices by custom user IDs assigned via API.\nNot compatible with any other targeting parameters\nExample: [\"custom-id-assigned-by-api\"]\nREQUIRED: REST API Key Authentication\nLimit of 2,000 entries per REST API call.\nNote: If targeting push, email, or sms subscribers with same ids, use with channelForExternalUserIds to indicate you are sending a push or email or sms.\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                    readonly nullable: true;
                                };
                                readonly includeEmailTokens: {
                                    readonly type: "array";
                                    readonly description: "Recommended for Sending Emails - Target specific email addresses.\nIf an email does not correspond to an existing user, a new user will be created.\nExample: nick@catfac.ts\nLimit of 2,000 entries per REST API call\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly includePhoneNumbers: {
                                    readonly type: "array";
                                    readonly description: "Recommended for Sending SMS - Target specific phone numbers. The phone number should be in the E.164 format. Phone number should be an existing subscriber on OneSignal. Refer our docs to learn how to add phone numbers to OneSignal.\nExample phone number: +1999999999\nLimit of 2,000 entries per REST API call\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly includeIosTokens: {
                                    readonly type: "array";
                                    readonly description: "Not Recommended: Please consider using includePlayerIds or includeExternalUserIds instead.\nTarget using iOS device tokens.\nWarning: Only works with Production tokens.\nAll non-alphanumeric characters must be removed from each token. If a token does not correspond to an existing user, a new user will be created.\nExample: ce777617da7f548fe7a9ab6febb56cf39fba6d38203...\nLimit of 2,000 entries per REST API call\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly includeWpWnsUris: {
                                    readonly type: "array";
                                    readonly description: "Not Recommended: Please consider using includePlayerIds or includeExternalUserIds instead.\nTarget using Windows URIs. If a token does not correspond to an existing user, a new user will be created.\nExample: http://s.notify.live.net/u/1/bn1/HmQAAACPaLDr-...\nLimit of 2,000 entries per REST API call\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly includeAmazonRegIds: {
                                    readonly type: "array";
                                    readonly description: "Not Recommended: Please consider using includePlayerIds or includeExternalUserIds instead.\nTarget using Amazon ADM registration IDs. If a token does not correspond to an existing user, a new user will be created.\nExample: amzn1.adm-registration.v1.XpvSSUk0Rc3hTVVV...\nLimit of 2,000 entries per REST API call\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly includeChromeRegIds: {
                                    readonly type: "array";
                                    readonly description: "Not Recommended: Please consider using includePlayerIds or includeExternalUserIds instead.\nTarget using Chrome App registration IDs. If a token does not correspond to an existing user, a new user will be created.\nExample: APA91bEeiUeSukAAUdnw3O2RB45FWlSpgJ7Ji_...\nLimit of 2,000 entries per REST API call\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly includeChromeWebRegIds: {
                                    readonly type: "array";
                                    readonly description: "Not Recommended: Please consider using includePlayerIds or includeExternalUserIds instead.\nTarget using Chrome Web Push registration IDs. If a token does not correspond to an existing user, a new user will be created.\nExample: APA91bEeiUeSukAAUdnw3O2RB45FWlSpgJ7Ji_...\nLimit of 2,000 entries per REST API call\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly includeAndroidRegIds: {
                                    readonly type: "array";
                                    readonly description: "Not Recommended: Please consider using includePlayerIds or includeExternalUserIds instead.\nTarget using Android device registration IDs. If a token does not correspond to an existing user, a new user will be created.\nExample: APA91bEeiUeSukAAUdnw3O2RB45FWlSpgJ7Ji_...\nLimit of 2,000 entries per REST API call\n";
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                };
                                readonly includeAliases: {
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly aliasLabel: {
                                            readonly type: "array";
                                            readonly items: {
                                                readonly type: "string";
                                            };
                                        };
                                    };
                                    readonly nullable: true;
                                };
                                readonly targetChannel: {
                                    readonly type: "string";
                                    readonly enum: readonly ["push", "email", "sms"];
                                };
                            };
                        }];
                    }, {
                        readonly type: "object";
                        readonly properties: {
                            readonly id: {
                                readonly type: "string";
                            };
                            readonly value: {
                                readonly type: "integer";
                                readonly readOnly: true;
                            };
                            readonly name: {
                                readonly type: "string";
                                readonly description: "Required for SMS Messages.\nAn identifier for tracking message within the OneSignal dashboard or export analytics.\nNot shown to end user.";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly aggregation: {
                                readonly type: "string";
                                readonly enum: readonly ["sum", "count"];
                                readonly readOnly: true;
                            };
                            readonly isIos: {
                                readonly type: "boolean";
                                readonly description: "Indicates whether to send to all devices registered under your app's Apple iOS platform.";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly isAndroid: {
                                readonly type: "boolean";
                                readonly description: "Indicates whether to send to all devices registered under your app's Google Android platform.";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly isHuawei: {
                                readonly type: "boolean";
                                readonly description: "Indicates whether to send to all devices registered under your app's Huawei Android platform.";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly isAnyWeb: {
                                readonly type: "boolean";
                                readonly description: "Indicates whether to send to all subscribed web browser users, including Chrome, Firefox, and Safari.\nYou may use this instead as a combined flag instead of separately enabling isChromeWeb, isFirefox, and isSafari, though the three options are equivalent to this one.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly isChromeWeb: {
                                readonly type: "boolean";
                                readonly writeOnly: true;
                                readonly nullable: true;
                                readonly description: "Indicates whether to send to all Google Chrome, Chrome on Android, and Mozilla Firefox users registered under your Chrome & Firefox web push platform.";
                            };
                            readonly isFirefox: {
                                readonly type: "boolean";
                                readonly writeOnly: true;
                                readonly nullable: true;
                                readonly description: "Indicates whether to send to all Mozilla Firefox desktop users registered under your Firefox web push platform.";
                            };
                            readonly isSafari: {
                                readonly type: "boolean";
                                readonly writeOnly: true;
                                readonly nullable: true;
                                readonly description: "Does not support iOS Safari. Indicates whether to send to all Apple's Safari desktop users registered under your Safari web push platform. Read more iOS Safari";
                            };
                            readonly isWpWns: {
                                readonly type: "boolean";
                                readonly writeOnly: true;
                                readonly nullable: true;
                                readonly description: "Indicates whether to send to all devices registered under your app's Windows platform.";
                            };
                            readonly isAdm: {
                                readonly type: "boolean";
                                readonly writeOnly: true;
                                readonly nullable: true;
                                readonly description: "Indicates whether to send to all devices registered under your app's Amazon Fire platform.";
                            };
                            readonly isChrome: {
                                readonly type: "boolean";
                                readonly writeOnly: true;
                                readonly nullable: true;
                                readonly description: "This flag is not used for web push Please see isChromeWeb for sending to web push users. This flag only applies to Google Chrome Apps & Extensions.\nIndicates whether to send to all devices registered under your app's Google Chrome Apps & Extension platform.\n";
                            };
                            readonly channelForExternalUserIds: {
                                readonly type: "string";
                                readonly writeOnly: true;
                                readonly description: "Indicates if the message type when targeting with includeExternalUserIds for cases where an email, sms, and/or push subscribers have the same external user id.\nExample: Use the string \"push\" to indicate you are sending a push notification or the string \"email\"for sending emails or \"sms\"for sending SMS.\n";
                            };
                            readonly appId: {
                                readonly type: "string";
                                readonly description: "Required: Your OneSignal Application ID, which can be found in Keys & IDs.\nIt is a UUID and looks similar to 8250eaf6-1a58-489e-b136-7c74a864b434.\n";
                                readonly writeOnly: true;
                            };
                            readonly externalId: {
                                readonly type: "string";
                                readonly description: "Correlation and idempotency key.\nA request received with this parameter will first look for another notification with the same externalId. If one exists, a notification will not be sent, and result of the previous operation will instead be returned. Therefore, if you plan on using this feature, it's important to use a good source of randomness to generate the UUID passed here.\nThis key is only idempotent for 30 days. After 30 days, the notification could be removed from our system and a notification with the same externalId will be sent again.\n  See Idempotent Notification Requests for more details\nwriteOnly: true\n";
                                readonly nullable: true;
                            };
                            readonly contents: {
                                readonly allOf: readonly [{
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly en: {
                                            readonly type: "string";
                                            readonly description: "Text in English.  Will be used as a fallback";
                                        };
                                        readonly ar: {
                                            readonly type: "string";
                                            readonly description: "Text in Arabic.";
                                        };
                                        readonly bs: {
                                            readonly type: "string";
                                            readonly description: "Text in Bosnian.";
                                        };
                                        readonly bg: {
                                            readonly type: "string";
                                            readonly description: "Text in Bulgarian.";
                                        };
                                        readonly ca: {
                                            readonly type: "string";
                                            readonly description: "Text in Catalan.";
                                        };
                                        readonly 'zh-Hans': {
                                            readonly type: "string";
                                            readonly description: "Text in Chinese (Simplified).";
                                        };
                                        readonly 'zh-Hant': {
                                            readonly type: "string";
                                            readonly description: "Text in Chinese (Traditional).";
                                        };
                                        readonly zh: {
                                            readonly type: "string";
                                            readonly description: "Alias for zh-Hans.";
                                        };
                                        readonly hr: {
                                            readonly type: "string";
                                            readonly description: "Text in Croatian.";
                                        };
                                        readonly cs: {
                                            readonly type: "string";
                                            readonly description: "Text in Czech.";
                                        };
                                        readonly da: {
                                            readonly type: "string";
                                            readonly description: "Text in Danish.";
                                        };
                                        readonly nl: {
                                            readonly type: "string";
                                            readonly description: "Text in Dutch.";
                                        };
                                        readonly et: {
                                            readonly type: "string";
                                            readonly description: "Text in Estonian.";
                                        };
                                        readonly fi: {
                                            readonly type: "string";
                                            readonly description: "Text in Finnish.";
                                        };
                                        readonly fr: {
                                            readonly type: "string";
                                            readonly description: "Text in French.";
                                        };
                                        readonly ka: {
                                            readonly type: "string";
                                            readonly description: "Text in Georgian.";
                                        };
                                        readonly de: {
                                            readonly type: "string";
                                            readonly description: "Text in German.";
                                        };
                                        readonly el: {
                                            readonly type: "string";
                                            readonly description: "Text in Greek.";
                                        };
                                        readonly hi: {
                                            readonly type: "string";
                                            readonly description: "Text in Hindi.";
                                        };
                                        readonly he: {
                                            readonly type: "string";
                                            readonly description: "Text in Hebrew.";
                                        };
                                        readonly hu: {
                                            readonly type: "string";
                                            readonly description: "Text in Hungarian.";
                                        };
                                        readonly id: {
                                            readonly type: "string";
                                            readonly description: "Text in Indonesian.";
                                        };
                                        readonly it: {
                                            readonly type: "string";
                                            readonly description: "Text in Italian.";
                                        };
                                        readonly ja: {
                                            readonly type: "string";
                                            readonly description: "Text in Japanese.";
                                        };
                                        readonly ko: {
                                            readonly type: "string";
                                            readonly description: "Text in Korean.";
                                        };
                                        readonly lv: {
                                            readonly type: "string";
                                            readonly description: "Text in Latvian.";
                                        };
                                        readonly lt: {
                                            readonly type: "string";
                                            readonly description: "Text in Lithuanian.";
                                        };
                                        readonly ms: {
                                            readonly type: "string";
                                            readonly description: "Text in Malay.";
                                        };
                                        readonly nb: {
                                            readonly type: "string";
                                            readonly description: "Text in Norwegian.";
                                        };
                                        readonly pl: {
                                            readonly type: "string";
                                            readonly description: "Text in Polish.";
                                        };
                                        readonly fa: {
                                            readonly type: "string";
                                            readonly description: "Text in Persian.";
                                        };
                                        readonly pt: {
                                            readonly type: "string";
                                            readonly description: "Text in Portuguese.";
                                        };
                                        readonly pa: {
                                            readonly type: "string";
                                            readonly description: "Text in Punjabi.";
                                        };
                                        readonly ro: {
                                            readonly type: "string";
                                            readonly description: "Text in Romanian.";
                                        };
                                        readonly ru: {
                                            readonly type: "string";
                                            readonly description: "Text in Russian.";
                                        };
                                        readonly sr: {
                                            readonly type: "string";
                                            readonly description: "Text in Serbian.";
                                        };
                                        readonly sk: {
                                            readonly type: "string";
                                            readonly description: "Text in Slovak.";
                                        };
                                        readonly es: {
                                            readonly type: "string";
                                            readonly description: "Text in Spanish.";
                                        };
                                        readonly sv: {
                                            readonly type: "string";
                                            readonly description: "Text in Swedish.";
                                        };
                                        readonly th: {
                                            readonly type: "string";
                                            readonly description: "Text in Thai.";
                                        };
                                        readonly tr: {
                                            readonly type: "string";
                                            readonly description: "Text in Turkish.";
                                        };
                                        readonly uk: {
                                            readonly type: "string";
                                            readonly description: "Text in Ukrainian.";
                                        };
                                        readonly vi: {
                                            readonly type: "string";
                                            readonly description: "Text in Vietnamese.";
                                        };
                                    };
                                }, {
                                    readonly description: "Required unless contentAvailable=true or templateId is set.\nThe message's content (excluding the title), a map of language codes to text for each language.\nEach hash must have a language code string for a key, mapped to the localized text you would like users to receive for that language.\nThis field supports inline substitutions.\nEnglish must be included in the hash.\nExample: {\"en\": \"English Message\", \"es\": \"Spanish Message\"}\n";
                                    readonly writeOnly: true;
                                }];
                            };
                            readonly headings: {
                                readonly allOf: readonly [{
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly en: {
                                            readonly type: "string";
                                            readonly description: "Text in English.  Will be used as a fallback";
                                        };
                                        readonly ar: {
                                            readonly type: "string";
                                            readonly description: "Text in Arabic.";
                                        };
                                        readonly bs: {
                                            readonly type: "string";
                                            readonly description: "Text in Bosnian.";
                                        };
                                        readonly bg: {
                                            readonly type: "string";
                                            readonly description: "Text in Bulgarian.";
                                        };
                                        readonly ca: {
                                            readonly type: "string";
                                            readonly description: "Text in Catalan.";
                                        };
                                        readonly 'zh-Hans': {
                                            readonly type: "string";
                                            readonly description: "Text in Chinese (Simplified).";
                                        };
                                        readonly 'zh-Hant': {
                                            readonly type: "string";
                                            readonly description: "Text in Chinese (Traditional).";
                                        };
                                        readonly zh: {
                                            readonly type: "string";
                                            readonly description: "Alias for zh-Hans.";
                                        };
                                        readonly hr: {
                                            readonly type: "string";
                                            readonly description: "Text in Croatian.";
                                        };
                                        readonly cs: {
                                            readonly type: "string";
                                            readonly description: "Text in Czech.";
                                        };
                                        readonly da: {
                                            readonly type: "string";
                                            readonly description: "Text in Danish.";
                                        };
                                        readonly nl: {
                                            readonly type: "string";
                                            readonly description: "Text in Dutch.";
                                        };
                                        readonly et: {
                                            readonly type: "string";
                                            readonly description: "Text in Estonian.";
                                        };
                                        readonly fi: {
                                            readonly type: "string";
                                            readonly description: "Text in Finnish.";
                                        };
                                        readonly fr: {
                                            readonly type: "string";
                                            readonly description: "Text in French.";
                                        };
                                        readonly ka: {
                                            readonly type: "string";
                                            readonly description: "Text in Georgian.";
                                        };
                                        readonly de: {
                                            readonly type: "string";
                                            readonly description: "Text in German.";
                                        };
                                        readonly el: {
                                            readonly type: "string";
                                            readonly description: "Text in Greek.";
                                        };
                                        readonly hi: {
                                            readonly type: "string";
                                            readonly description: "Text in Hindi.";
                                        };
                                        readonly he: {
                                            readonly type: "string";
                                            readonly description: "Text in Hebrew.";
                                        };
                                        readonly hu: {
                                            readonly type: "string";
                                            readonly description: "Text in Hungarian.";
                                        };
                                        readonly id: {
                                            readonly type: "string";
                                            readonly description: "Text in Indonesian.";
                                        };
                                        readonly it: {
                                            readonly type: "string";
                                            readonly description: "Text in Italian.";
                                        };
                                        readonly ja: {
                                            readonly type: "string";
                                            readonly description: "Text in Japanese.";
                                        };
                                        readonly ko: {
                                            readonly type: "string";
                                            readonly description: "Text in Korean.";
                                        };
                                        readonly lv: {
                                            readonly type: "string";
                                            readonly description: "Text in Latvian.";
                                        };
                                        readonly lt: {
                                            readonly type: "string";
                                            readonly description: "Text in Lithuanian.";
                                        };
                                        readonly ms: {
                                            readonly type: "string";
                                            readonly description: "Text in Malay.";
                                        };
                                        readonly nb: {
                                            readonly type: "string";
                                            readonly description: "Text in Norwegian.";
                                        };
                                        readonly pl: {
                                            readonly type: "string";
                                            readonly description: "Text in Polish.";
                                        };
                                        readonly fa: {
                                            readonly type: "string";
                                            readonly description: "Text in Persian.";
                                        };
                                        readonly pt: {
                                            readonly type: "string";
                                            readonly description: "Text in Portuguese.";
                                        };
                                        readonly pa: {
                                            readonly type: "string";
                                            readonly description: "Text in Punjabi.";
                                        };
                                        readonly ro: {
                                            readonly type: "string";
                                            readonly description: "Text in Romanian.";
                                        };
                                        readonly ru: {
                                            readonly type: "string";
                                            readonly description: "Text in Russian.";
                                        };
                                        readonly sr: {
                                            readonly type: "string";
                                            readonly description: "Text in Serbian.";
                                        };
                                        readonly sk: {
                                            readonly type: "string";
                                            readonly description: "Text in Slovak.";
                                        };
                                        readonly es: {
                                            readonly type: "string";
                                            readonly description: "Text in Spanish.";
                                        };
                                        readonly sv: {
                                            readonly type: "string";
                                            readonly description: "Text in Swedish.";
                                        };
                                        readonly th: {
                                            readonly type: "string";
                                            readonly description: "Text in Thai.";
                                        };
                                        readonly tr: {
                                            readonly type: "string";
                                            readonly description: "Text in Turkish.";
                                        };
                                        readonly uk: {
                                            readonly type: "string";
                                            readonly description: "Text in Ukrainian.";
                                        };
                                        readonly vi: {
                                            readonly type: "string";
                                            readonly description: "Text in Vietnamese.";
                                        };
                                    };
                                }, {
                                    readonly description: "The message's title, a map of language codes to text for each language. Each hash must have a language code string for a key, mapped to the localized text you would like users to receive for that language.\nThis field supports inline substitutions.\nExample: {\"en\": \"English Title\", \"es\": \"Spanish Title\"}\n";
                                    readonly writeOnly: true;
                                }];
                            };
                            readonly subtitle: {
                                readonly allOf: readonly [{
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly en: {
                                            readonly type: "string";
                                            readonly description: "Text in English.  Will be used as a fallback";
                                        };
                                        readonly ar: {
                                            readonly type: "string";
                                            readonly description: "Text in Arabic.";
                                        };
                                        readonly bs: {
                                            readonly type: "string";
                                            readonly description: "Text in Bosnian.";
                                        };
                                        readonly bg: {
                                            readonly type: "string";
                                            readonly description: "Text in Bulgarian.";
                                        };
                                        readonly ca: {
                                            readonly type: "string";
                                            readonly description: "Text in Catalan.";
                                        };
                                        readonly 'zh-Hans': {
                                            readonly type: "string";
                                            readonly description: "Text in Chinese (Simplified).";
                                        };
                                        readonly 'zh-Hant': {
                                            readonly type: "string";
                                            readonly description: "Text in Chinese (Traditional).";
                                        };
                                        readonly zh: {
                                            readonly type: "string";
                                            readonly description: "Alias for zh-Hans.";
                                        };
                                        readonly hr: {
                                            readonly type: "string";
                                            readonly description: "Text in Croatian.";
                                        };
                                        readonly cs: {
                                            readonly type: "string";
                                            readonly description: "Text in Czech.";
                                        };
                                        readonly da: {
                                            readonly type: "string";
                                            readonly description: "Text in Danish.";
                                        };
                                        readonly nl: {
                                            readonly type: "string";
                                            readonly description: "Text in Dutch.";
                                        };
                                        readonly et: {
                                            readonly type: "string";
                                            readonly description: "Text in Estonian.";
                                        };
                                        readonly fi: {
                                            readonly type: "string";
                                            readonly description: "Text in Finnish.";
                                        };
                                        readonly fr: {
                                            readonly type: "string";
                                            readonly description: "Text in French.";
                                        };
                                        readonly ka: {
                                            readonly type: "string";
                                            readonly description: "Text in Georgian.";
                                        };
                                        readonly de: {
                                            readonly type: "string";
                                            readonly description: "Text in German.";
                                        };
                                        readonly el: {
                                            readonly type: "string";
                                            readonly description: "Text in Greek.";
                                        };
                                        readonly hi: {
                                            readonly type: "string";
                                            readonly description: "Text in Hindi.";
                                        };
                                        readonly he: {
                                            readonly type: "string";
                                            readonly description: "Text in Hebrew.";
                                        };
                                        readonly hu: {
                                            readonly type: "string";
                                            readonly description: "Text in Hungarian.";
                                        };
                                        readonly id: {
                                            readonly type: "string";
                                            readonly description: "Text in Indonesian.";
                                        };
                                        readonly it: {
                                            readonly type: "string";
                                            readonly description: "Text in Italian.";
                                        };
                                        readonly ja: {
                                            readonly type: "string";
                                            readonly description: "Text in Japanese.";
                                        };
                                        readonly ko: {
                                            readonly type: "string";
                                            readonly description: "Text in Korean.";
                                        };
                                        readonly lv: {
                                            readonly type: "string";
                                            readonly description: "Text in Latvian.";
                                        };
                                        readonly lt: {
                                            readonly type: "string";
                                            readonly description: "Text in Lithuanian.";
                                        };
                                        readonly ms: {
                                            readonly type: "string";
                                            readonly description: "Text in Malay.";
                                        };
                                        readonly nb: {
                                            readonly type: "string";
                                            readonly description: "Text in Norwegian.";
                                        };
                                        readonly pl: {
                                            readonly type: "string";
                                            readonly description: "Text in Polish.";
                                        };
                                        readonly fa: {
                                            readonly type: "string";
                                            readonly description: "Text in Persian.";
                                        };
                                        readonly pt: {
                                            readonly type: "string";
                                            readonly description: "Text in Portuguese.";
                                        };
                                        readonly pa: {
                                            readonly type: "string";
                                            readonly description: "Text in Punjabi.";
                                        };
                                        readonly ro: {
                                            readonly type: "string";
                                            readonly description: "Text in Romanian.";
                                        };
                                        readonly ru: {
                                            readonly type: "string";
                                            readonly description: "Text in Russian.";
                                        };
                                        readonly sr: {
                                            readonly type: "string";
                                            readonly description: "Text in Serbian.";
                                        };
                                        readonly sk: {
                                            readonly type: "string";
                                            readonly description: "Text in Slovak.";
                                        };
                                        readonly es: {
                                            readonly type: "string";
                                            readonly description: "Text in Spanish.";
                                        };
                                        readonly sv: {
                                            readonly type: "string";
                                            readonly description: "Text in Swedish.";
                                        };
                                        readonly th: {
                                            readonly type: "string";
                                            readonly description: "Text in Thai.";
                                        };
                                        readonly tr: {
                                            readonly type: "string";
                                            readonly description: "Text in Turkish.";
                                        };
                                        readonly uk: {
                                            readonly type: "string";
                                            readonly description: "Text in Ukrainian.";
                                        };
                                        readonly vi: {
                                            readonly type: "string";
                                            readonly description: "Text in Vietnamese.";
                                        };
                                    };
                                }, {
                                    readonly description: "The message's subtitle, a map of language codes to text for each language. Each hash must have a language code string for a key, mapped to the localized text you would like users to receive for that language.\nThis field supports inline substitutions.\nExample: {\"en\": \"English Subtitle\", \"es\": \"Spanish Subtitle\"}\n";
                                    readonly writeOnly: true;
                                }];
                            };
                            readonly data: {
                                readonly type: "object";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\nA custom map of data that is passed back to your app. Same as using Additional Data within the dashboard. Can use up to 2048 bytes of data.\nExample: {\"abc\": 123, \"foo\": \"bar\", \"event_performed\": true, \"amount\": 12.1}\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly huaweiMsgType: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\nUse \"data\" or \"message\" depending on the type of notification you are sending. More details in Data & Background Notifications.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly url: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: All\nThe URL to open in the browser when a user clicks on the notification.\nNote: iOS needs https or updated NSAppTransportSecurity in plist\nThis field supports inline substitutions.\nOmit if including webUrl or appUrl\nExample: https://onesignal.com\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly webUrl: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: All Browsers\nSame as url but only sent to web push platforms.\nIncluding Chrome, Firefox, Safari, Opera, etc.\nExample: https://onesignal.com\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly appUrl: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: All Browsers\nSame as url but only sent to web push platforms.\nIncluding iOS, Android, macOS, Windows, ChromeApps, etc.\nExample: https://onesignal.com\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly iosAttachments: {
                                readonly type: "object";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS 10+\nAdds media attachments to notifications. Set as JSON object, key as a media id of your choice and the value as a valid local filename or URL. User must press and hold on the notification to view.\nDo not set mutableContent to download attachments. The OneSignal SDK does this automatically\nExample: {\"id1\": \"https://domain.com/image.jpg\"}\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly templateId: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: All\nUse a template you setup on our dashboard. The templateId is the UUID found in the URL when viewing a template on our dashboard.\nExample: be4a8044-bbd6-11e4-a581-000c2940e62c\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly contentAvailable: {
                                readonly type: "boolean";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS\nSending true wakes your app from background to run custom native code (Apple interprets this as content-available=1). Note: Not applicable if the app is in the \"force-quit\" state (i.e app was swiped away). Omit the contents field to prevent displaying a visible notification.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly mutableContent: {
                                readonly type: "boolean";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS 10+\nAlways defaults to true and cannot be turned off. Allows tracking of notification receives and changing of the notification content in your app before it is displayed. Triggers didReceive(_:withContentHandler:) on your UNNotificationServiceExtension.\n";
                                readonly writeOnly: true;
                            };
                            readonly targetContentIdentifier: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS 13+\nUse to target a specific experience in your App Clip, or to target your notification to a specific window in a multi-scene App.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly bigPicture: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\nPicture to display in the expanded view. Can be a drawable resource name or a URL.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly huaweiBigPicture: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\nPicture to display in the expanded view. Can be a drawable resource name or a URL.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly admBigPicture: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Amazon\nPicture to display in the expanded view. Can be a drawable resource name or a URL.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly chromeBigPicture: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: ChromeApp\nLarge picture to display below the notification text. Must be a local URL.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly chromeWebImage: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Chrome 56+\nSets the web push notification's large image to be shown below the notification's title and text. Please see Web Push Notification Icons.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly buttons: {
                                readonly type: "array";
                                readonly items: {
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly id: {
                                            readonly type: "string";
                                        };
                                        readonly text: {
                                            readonly type: "string";
                                        };
                                        readonly icon: {
                                            readonly type: "string";
                                        };
                                    };
                                    readonly required: readonly ["id"];
                                };
                                readonly description: "Channel: Push Notifications\nPlatform: iOS 8.0+, Android 4.1+, and derivatives like Amazon Buttons to add to the notification. Icon only works for Android.\nButtons show in reverse order of array position i.e. Last item in array shows as first button on device.\nExample: [{\"id\": \"id2\", \"text\": \"second button\", \"icon\": \"ic_menu_share\"}, {\"id\": \"id1\", \"text\": \"first button\", \"icon\": \"ic_menu_send\"}]\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly webButtons: {
                                readonly type: "array";
                                readonly items: {
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly id: {
                                            readonly type: "string";
                                        };
                                        readonly text: {
                                            readonly type: "string";
                                        };
                                        readonly icon: {
                                            readonly type: "string";
                                        };
                                    };
                                    readonly required: readonly ["id"];
                                };
                                readonly description: "Channel: Push Notifications\nPlatform: Chrome 48+\nAdd action buttons to the notification. The id field is required.\nExample: [{\"id\": \"like-button\", \"text\": \"Like\", \"icon\": \"http://i.imgur.com/N8SN8ZS.png\", \"url\": \"https://yoursite.com\"}, {\"id\": \"read-more-button\", \"text\": \"Read more\", \"icon\": \"http://i.imgur.com/MIxJp1L.png\", \"url\": \"https://yoursite.com\"}]\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly iosCategory: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS\nCategory APS payload, use with registerUserNotificationSettings:categories in your Objective-C / Swift code.\nExample: calendar category which contains actions like accept and decline\niOS 10+ This will trigger your UNNotificationContentExtension whose ID matches this category.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly androidChannelId: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\nThe Android Oreo Notification Category to send the notification under. See the Category documentation on creating one and getting it's id.\n";
                                readonly writeOnly: true;
                            };
                            readonly huaweiChannelId: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\nThe Android Oreo Notification Category to send the notification under. See the Category documentation on creating one and getting it's id.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly existingAndroidChannelId: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\nUse this if you have client side Android Oreo Channels you have already defined in your app with code.\n";
                                readonly writeOnly: true;
                            };
                            readonly huaweiExistingChannelId: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\nUse this if you have client side Android Oreo Channels you have already defined in your app with code.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly androidBackgroundLayout: {
                                readonly type: "object";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\nAllowing setting a background image for the notification. This is a JSON object containing the following keys. See our Background Image documentation for image sizes.\n";
                                readonly properties: {
                                    readonly image: {
                                        readonly type: "string";
                                        readonly description: "Asset file, android resource name, or URL to remote image.";
                                    };
                                    readonly headingsColor: {
                                        readonly type: "string";
                                        readonly description: "Title text color ARGB Hex format. Example(Blue) \"FF0000FF\".";
                                    };
                                    readonly contentsColor: {
                                        readonly type: "string";
                                        readonly description: "Body text color ARGB Hex format. Example(Red) \"FFFF0000\".";
                                    };
                                };
                                readonly writeOnly: true;
                            };
                            readonly smallIcon: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\nIcon shown in the status bar and on the top left of the notification.\nIf not set a bell icon will be used or ic_stat_onesignal_default if you have set this resource name.\nSee: How to create small icons\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly huaweiSmallIcon: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\nIcon shown in the status bar and on the top left of the notification.\nUse an Android resource path (E.g. /drawable/smallIcon).\nDefaults to your app icon if not set.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly largeIcon: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\nCan be a drawable resource name or a URL.\nSee: How to create large icons\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly huaweiLargeIcon: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\nCan be a drawable resource name or a URL.\nSee: How to create large icons\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly admSmallIcon: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Amazon\nIf not set a bell icon will be used or ic_stat_onesignal_default if you have set this resource name.\nSee: How to create small icons\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly admLargeIcon: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Amazon\nIf blank the smallIcon is used. Can be a drawable resource name or a URL.\nSee: How to create large icons\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly chromeWebIcon: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Chrome\nSets the web push notification's icon. An image URL linking to a valid image. Common image types are supported; GIF will not animate. We recommend 256x256 (at least 80x80) to display well on high DPI devices. Firefox will also use this icon, unless you specify firefoxIcon.\n";
                                readonly nullable: true;
                            };
                            readonly chromeWebBadge: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Chrome\nSets the web push notification icon for Android devices in the notification shade. Please see Web Push Notification Badge.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly firefoxIcon: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Firefox\nNot recommended Few people need to set Firefox-specific icons. We recommend setting chromeWebIcon instead, which Firefox will also use.\nSets the web push notification's icon for Firefox. An image URL linking to a valid image. Common image types are supported; GIF will not animate. We recommend 256x256 (at least 80x80) to display well on high DPI devices.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly chromeIcon: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: ChromeApp\nThis flag is not used for web push For web push, please see chromeWebIcon instead.\nThe local URL to an icon to use. If blank, the app icon will be used.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly iosSound: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS\nSound file that is included in your app to play instead of the default device notification sound. Pass nil to disable vibration and sound for the notification.\nExample: \"notification.wav\"\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly androidSound: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\n&#9888;&#65039;Deprecated, this field doesn't work on Android 8 (Oreo) and newer devices!\nPlease use Notification Categories / Channels noted above instead to support ALL versions of Android.\nSound file that is included in your app to play instead of the default device notification sound. Pass nil to disable sound for the notification.\nNOTE: Leave off file extension for Android.\nExample: \"notification\"\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly huaweiSound: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\n&#9888;&#65039;Deprecated, this field ONLY works on EMUI 5 (Android 7 based) and older devices.\nPlease also set Notification Categories / Channels noted above to support EMUI 8 (Android 8 based) devices.\nSound file that is included in your app to play instead of the default device notification sound. NOTE: Leave off file extension for and include the full path.\n\nExample: \"/res/raw/notification\"\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly admSound: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Amazon\n&#9888;&#65039;Deprecated, this field doesn't work on Android 8 (Oreo) and newer devices!\nPlease use Notification Categories / Channels noted above instead to support ALL versions of Android.\nSound file that is included in your app to play instead of the default device notification sound. Pass nil to disable sound for the notification.\nNOTE: Leave off file extension for Android.\nExample: \"notification\"\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly wpWnsSound: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Windows\nSound file that is included in your app to play instead of the default device notification sound.\nExample: \"notification.wav\"\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly androidLedColor: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\n&#9888;&#65039;Deprecated, this field doesn't work on Android 8 (Oreo) and newer devices!\nPlease use Notification Categories / Channels noted above instead to support ALL versions of Android.\nSets the devices LED notification light if the device has one. ARGB Hex format.\nExample(Blue): \"FF0000FF\"\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly huaweiLedColor: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\n&#9888;&#65039;Deprecated, this field ONLY works on EMUI 5 (Android 7 based) and older devices.\nPlease also set Notification Categories / Channels noted above to support EMUI 8 (Android 8 based) devices.\nSets the devices LED notification light if the device has one. RGB Hex format.\nExample(Blue): \"0000FF\"\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly androidAccentColor: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\nSets the background color of the notification circle to the left of the notification text. Only applies to apps targeting Android API level 21+ on Android 5.0+ devices.\nExample(Red): \"FFFF0000\"\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly huaweiAccentColor: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\nAccent Color used on Action Buttons and Group overflow count.\nUses RGB Hex value (E.g. #9900FF).\nDefaults to device's theme color if not set.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly androidVisibility: {
                                readonly type: "integer";
                                readonly description: "Channel: Push Notifications\nPlatform: Android 5.0_\n&#9888;&#65039;Deprecated, this field doesn't work on Android 8 (Oreo) and newer devices!\nPlease use Notification Categories / Channels noted above instead to support ALL versions of Android.\n1 = Public (default) (Shows the full message on the lock screen unless the user has disabled all notifications from showing on the lock screen. Please consider the user and mark private if the contents are.)\n0 = Private (Hides message contents on lock screen if the user set \"Hide sensitive notification content\" in the system settings)\n-1 = Secret (Notification does not show on the lock screen at all)\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly huaweiVisibility: {
                                readonly type: "integer";
                                readonly nullable: true;
                                readonly description: "Channel: Push Notifications\nPlatform: Huawei\n&#9888;&#65039;Deprecated, this field ONLY works on EMUI 5 (Android 7 based) and older devices.\nPlease also set Notification Categories / Channels noted above to support EMUI 8 (Android 8 based) devices.\n1 = Public (default) (Shows the full message on the lock screen unless the user has disabled all notifications from showing on the lock screen. Please consider the user and mark private if the contents are.)\n0 = Private (Hides message contents on lock screen if the user set \"Hide sensitive notification content\" in the system settings)\n-1 = Secret (Notification does not show on the lock screen at all)\n";
                                readonly writeOnly: true;
                            };
                            readonly iosBadgeType: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS\nDescribes whether to set or increase/decrease your app's iOS badge count by the iosBadgeCount specified count. Can specify None, SetTo, or Increase.\n`None` leaves the count unaffected.\n`SetTo` directly sets the badge count to the number specified in iosBadgeCount.\n`Increase` adds the number specified in iosBadgeCount to the total. Use a negative number to decrease the badge count.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly iosBadgeCount: {
                                readonly type: "integer";
                                readonly nullable: true;
                                readonly description: "Channel: Push Notifications\nPlatform: iOS\nUsed with iosBadgeType, describes the value to set or amount to increase/decrease your app's iOS badge count by.\nYou can use a negative number to decrease the badge count when used with an iosBadgeType of Increase.\n";
                                readonly writeOnly: true;
                            };
                            readonly collapseId: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS 10+, Android\nOnly one notification with the same id will be shown on the device. Use the same id to update an existing notification instead of showing a new one. Limit of 64 characters.\n";
                                readonly writeOnly: true;
                            };
                            readonly webPushTopic: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: All Browsers\nDisplay multiple notifications at once with different topics.\n";
                                readonly nullable: true;
                            };
                            readonly apnsAlert: {
                                readonly type: "object";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS 10+\niOS can localize push notification messages on the client using special parameters such as loc-key. When using the Create Notification endpoint, you must include these parameters inside of a field called apnsAlert. Please see Apple's guide on localizing push notifications to learn more.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly delayedOption: {
                                readonly type: "string";
                                readonly description: "Channel: All\nPossible values are:\ntimezone (Deliver at a specific time-of-day in each users own timezone)\nlast-active Same as Intelligent Delivery . (Deliver at the same time of day as each user last used your app).\nIf sendAfter is used, this takes effect after the sendAfter time has elapsed.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly deliveryTimeOfDay: {
                                readonly type: "string";
                                readonly description: "Channel: All\nUse with delayedOption=timezone.\nExamples: \"9:00AM\"\n\"21:45\"\n\"9:45:30\"\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly ttl: {
                                readonly type: "integer";
                                readonly nullable: true;
                                readonly description: "Channel: Push Notifications\nPlatform: iOS, Android, Chrome, Firefox, Safari, ChromeWeb\nTime To Live - In seconds. The notification will be expired if the device does not come back online within this time. The default is 259,200 seconds (3 days).\nMax value to set is 2419200 seconds (28 days).\n";
                                readonly writeOnly: true;
                            };
                            readonly priority: {
                                readonly type: "integer";
                                readonly nullable: true;
                                readonly description: "Channel: Push Notifications\nPlatform: Android, Chrome, ChromeWeb\nDelivery priority through the push server (example GCM/FCM). Pass 10 for high priority or any other integer for normal priority. Defaults to normal priority for Android and high for iOS. For Android 6.0+ devices setting priority to high will wake the device out of doze mode.\n";
                                readonly writeOnly: true;
                            };
                            readonly apnsPushTypeOverride: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS\nvalid values: voip\nSet the value to voip for sending VoIP Notifications\nThis field maps to the APNS header apns-push-type.\nNote: alert and background are automatically set by OneSignal\n";
                                readonly writeOnly: true;
                            };
                            readonly throttleRatePerMinute: {
                                readonly type: "string";
                                readonly description: "Channel: All\nApps with throttling enabled:\n  - the parameter value will be used to override the default application throttling value set from the dashboard settings.\n  - parameter value 0 indicates not to apply throttling to the notification.\n  - if the parameter is not passed then the default app throttling value will be applied to the notification.\nApps with throttling disabled:\n  - this parameter can be used to throttle delivery for the notification even though throttling is not enabled at the application level.\nRefer to throttling for more details.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly androidGroup: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\nNotifications with the same group will be stacked together using Android's Notification Grouping feature.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly androidGroupMessage: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Android\nNote: This only works for Android 6 and older. Android 7+ allows full expansion of all message.\nSummary message to display when 2+ notifications are stacked together. Default is \"# new messages\". Include $[notif_count] in your message and it will be replaced with the current number.\nLanguages - The value of each key is the message that will be sent to users for that language. \"en\" (English) is required. The key of each hash is either a a 2 character language code or one of zh-Hans/zh-Hant for Simplified or Traditional Chinese. Read more: supported languages.\nExample: {\"en\": \"You have $[notif_count] new messages\"}\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly admGroup: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: Amazon\nNotifications with the same group will be stacked together using Android's Notification Grouping feature.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly admGroupMessage: {
                                readonly type: "object";
                                readonly description: "Channel: Push Notifications\nPlatform: Amazon\nSummary message to display when 2+ notifications are stacked together. Default is \"# new messages\". Include $[notif_count] in your message and it will be replaced with the current number. \"en\" (English) is required. The key of each hash is either a a 2 character language code or one of zh-Hans/zh-Hant for Simplified or Traditional Chinese. The value of each key is the message that will be sent to users for that language.\nExample: {\"en\": \"You have $[notif_count] new messages\"}\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly threadId: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS 12+\nThis parameter is supported in iOS 12 and above. It allows you to group related notifications together.\nIf two notifications have the same thread-id, they will both be added to the same group.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly summaryArg: {
                                readonly type: "string";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS 12+\nWhen using threadId to create grouped notifications in iOS 12+, you can also control the summary. For example, a grouped notification can say \"12 more notifications from John Doe\".\nThe summaryArg lets you set the name of the person/thing the notifications are coming from, and will show up as \"X more notifications from summaryArg\"\n";
                                readonly writeOnly: true;
                            };
                            readonly summaryArgCount: {
                                readonly type: "integer";
                                readonly description: "Channel: Push Notifications\nPlatform: iOS 12+\nWhen using threadId, you can also control the count of the number of notifications in the group. For example, if the group already has 12 notifications, and you send a new notification with summaryArgCount = 2, the new total will be 14 and the summary will be \"14 more notifications from summaryArg\"\n";
                                readonly writeOnly: true;
                            };
                            readonly emailSubject: {
                                readonly type: "string";
                                readonly description: "Channel: Email\nRequired.  The subject of the email.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly emailBody: {
                                readonly type: "string";
                                readonly description: "Channel: Email\nRequired unless templateId is set.\nHTML suported\nThe body of the email you wish to send. Typically, customers include their own HTML templates here. Must include [unsubscribe_url] in an <a> tag somewhere in the email.\nNote: any malformed HTML content will be sent to users. Please double-check your HTML is valid.\n";
                                readonly writeOnly: true;
                            };
                            readonly emailFromName: {
                                readonly type: "string";
                                readonly description: "Channel: Email\nThe name the email is from. If not specified, will default to \"from name\" set in the OneSignal Dashboard Email Settings.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly emailFromAddress: {
                                readonly type: "string";
                                readonly description: "Channel: Email\nThe email address the email is from. If not specified, will default to \"from email\" set in the OneSignal Dashboard Email Settings.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly emailPreheader: {
                                readonly type: "string";
                                readonly description: "Channel: Email\nThe preheader text of the email.\nPreheader is the preview text displayed immediately after an email subject that provides additional context about the email content.\nIf not specified, will default to null.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly includeUnsubscribed: {
                                readonly type: "boolean";
                                readonly description: "Channel: Email\nDefault is `false`. This field is used to send transactional notifications. If set to `true`, this notification will also be sent to unsubscribed emails. If a `templateId` is provided, the `includeUnsubscribed` value from the template will be inherited. If you are using a third-party ESP, this field requires the ESP's list of unsubscribed emails to be cleared.";
                                readonly writeOnly: true;
                            };
                            readonly smsFrom: {
                                readonly type: "string";
                                readonly description: "Channel: SMS\nPhone Number used to send SMS. Should be a registered Twilio phone number in E.164 format.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly smsMediaUrls: {
                                readonly type: "array";
                                readonly items: {
                                    readonly type: "string";
                                };
                                readonly description: "Channel: SMS\nURLs for the media files to be attached to the SMS content.\nLimit: 10 media urls with a total max. size of 5MBs.\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                            readonly filters: {
                                readonly type: "array";
                                readonly nullable: true;
                                readonly items: {
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly field: {
                                            readonly type: "string";
                                            readonly description: "Name of the field to use as the first operand in the filter expression.";
                                        };
                                        readonly key: {
                                            readonly type: "string";
                                            readonly description: "If `field` is `tag`, this field is *required* to specify `key` inside the tags.";
                                        };
                                        readonly value: {
                                            readonly type: "string";
                                            readonly description: "Constant value to use as the second operand in the filter expression. This value is *required* when the relation operator is a binary operator.";
                                        };
                                        readonly relation: {
                                            readonly type: "string";
                                            readonly description: "Operator of a filter expression.";
                                            readonly enum: readonly [">", "<", "=", "!=", "exists", "not_exists", "time_elapsed_gt", "time_elapsed_lt"];
                                        };
                                    };
                                    readonly required: readonly ["field", "relation"];
                                };
                            };
                            readonly customData: {
                                readonly type: "object";
                                readonly description: "Channel: All\nJSON object that can be used as a source of message personalization data for fields that support tag variable substitution.\nPush, SMS: Can accept up to 2048 bytes of valid JSON. Email: Can accept up to 10000 bytes of valid JSON.\nExample: {\"order_id\": 123, \"currency\": \"USD\", \"amount\": 25}\n";
                                readonly writeOnly: true;
                                readonly nullable: true;
                            };
                        };
                    }, {
                        readonly required: readonly ["appId"];
                    }];
                }, {
                    readonly type: "object";
                    readonly properties: {
                        readonly sendAfter: {
                            readonly type: "string";
                            readonly format: "date-time";
                            readonly description: "Channel: All\nSchedule notification for future delivery. API defaults to UTC -1100\nExamples: All examples are the exact same date & time.\n\"Thu Sep 24 2015 14:00:00 GMT-0700 (PDT)\"\n\"September 24th 2015, 2:00:00 pm UTC-07:00\"\n\"2015-09-24 14:00:00 GMT-0700\"\n\"Sept 24 2015 14:00:00 GMT-0700\"\n\"Thu Sep 24 2015 14:00:00 GMT-0700 (Pacific Daylight Time)\"\nNote: SMS currently only supports sendAfter parameter.\n";
                            readonly writeOnly: true;
                            readonly nullable: true;
                        };
                    };
                }];
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'pusher-beams': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly pushpad: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly 'push-webhook': {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
        readonly appio: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: true;
            };
        };
    };
    readonly in_app: {
        readonly novu: {
            output: {
                readonly type: "object";
                readonly properties: {};
                readonly required: readonly [];
                readonly additionalProperties: false;
            };
        };
    };
};

type Passthrough = {
    body?: Record<string, unknown>;
    headers?: Record<string, string>;
    query?: Record<string, string>;
};
type WithPassthrough<T> = Prettify<T & {
    _passthrough?: Passthrough;
}>;
type Providers<T_StepType extends keyof typeof providerSchemas, T_Controls, T_Output> = {
    [K in keyof (typeof providerSchemas)[T_StepType]]?: (step: {
        /**
         * The controls for the step.
         */
        controls: T_Controls;
        /**
         * The outputs of the step.
         */
        outputs: T_Output;
    }) => Awaitable<WithPassthrough<FromSchemaUnvalidated<(typeof providerSchemas)[T_StepType][K]['output']>>>;
};

declare const actionStepSchemas: {
    delay: {
        output: {
            readonly oneOf: [{
                readonly type: "object";
                readonly properties: {
                    readonly type: {
                        readonly enum: readonly ["regular"];
                    };
                    readonly amount: {
                        readonly type: "number";
                    };
                    readonly unit: {
                        readonly type: "string";
                        readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
                    };
                    readonly extendToSchedule: {
                        readonly type: "boolean";
                    };
                };
                readonly required: readonly ["amount", "unit"];
                readonly additionalProperties: false;
            }, {
                readonly type: "object";
                readonly properties: {
                    readonly type: {
                        readonly enum: readonly ["timed"];
                    };
                    readonly cron: {
                        readonly type: "string";
                    };
                    readonly extendToSchedule: {
                        readonly type: "boolean";
                    };
                };
                readonly required: readonly ["cron"];
                readonly additionalProperties: false;
            }, {
                readonly type: "object";
                readonly properties: {
                    readonly type: {
                        readonly enum: readonly ["dynamic"];
                    };
                    readonly dynamicKey: {
                        readonly type: "string";
                    };
                    readonly extendToSchedule: {
                        readonly type: "boolean";
                    };
                };
                readonly required: readonly ["dynamicKey"];
                readonly additionalProperties: false;
            }];
        };
        result: {
            readonly type: "object";
            readonly properties: {
                readonly duration: {
                    readonly type: "number";
                };
            };
            readonly required: readonly ["duration"];
            readonly additionalProperties: false;
        };
    };
    digest: {
        output: {
            readonly oneOf: [{
                readonly type: "object";
                readonly properties: {
                    readonly type: {
                        readonly enum: readonly ["regular"];
                    };
                    readonly amount: {
                        readonly type: "number";
                    };
                    readonly unit: {
                        readonly type: "string";
                        readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
                    };
                    readonly digestKey: {
                        readonly type: "string";
                    };
                    readonly lookBackWindow: {
                        readonly type: "object";
                        readonly properties: {
                            readonly amount: {
                                readonly type: "number";
                            };
                            readonly unit: {
                                readonly type: "string";
                                readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
                            };
                        };
                        readonly required: readonly ["amount", "unit"];
                        readonly additionalProperties: false;
                    };
                    readonly extendToSchedule: {
                        readonly type: "boolean";
                    };
                };
                readonly required: readonly ["amount", "unit"];
                readonly additionalProperties: false;
            }, {
                readonly type: "object";
                readonly properties: {
                    readonly type: {
                        readonly enum: readonly ["timed"];
                    };
                    readonly cron: {
                        readonly type: "string";
                    };
                    readonly digestKey: {
                        readonly type: "string";
                    };
                    readonly extendToSchedule: {
                        readonly type: "boolean";
                    };
                };
                readonly required: readonly ["cron"];
                readonly additionalProperties: false;
            }];
        };
        result: {
            readonly type: "object";
            readonly properties: {
                readonly eventCount: {
                    readonly type: "number";
                };
                readonly events: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "object";
                        readonly properties: {
                            readonly id: {
                                readonly type: "string";
                            };
                            readonly time: {
                                readonly type: "string";
                            };
                            readonly payload: {
                                readonly type: "object";
                            };
                        };
                        readonly required: readonly ["id", "time", "payload"];
                        readonly additionalProperties: false;
                    };
                };
            };
            readonly required: readonly ["events"];
            readonly additionalProperties: false;
        };
    };
    throttle: {
        output: {
            readonly type: "object";
            readonly properties: {
                readonly type: {
                    readonly type: "string";
                    readonly enum: readonly ["fixed", "dynamic"];
                };
                readonly amount: {
                    readonly type: "number";
                };
                readonly unit: {
                    readonly type: "string";
                    readonly enum: readonly ["minutes", "hours", "days"];
                };
                readonly dynamicKey: {
                    readonly type: "string";
                };
                readonly threshold: {
                    readonly type: "number";
                };
                readonly throttleKey: {
                    readonly type: "string";
                };
            };
            readonly required: readonly ["type"];
            readonly additionalProperties: false;
        };
        result: {
            readonly type: "object";
            readonly properties: {
                readonly throttled: {
                    readonly type: "boolean";
                    readonly description: "Whether the workflow execution was throttled";
                };
                readonly executionCount: {
                    readonly type: "number";
                    readonly description: "Number of executions within the throttle window";
                };
                readonly threshold: {
                    readonly type: "number";
                    readonly description: "The throttle threshold that was applied";
                };
                readonly windowStart: {
                    readonly type: "string";
                    readonly format: "date-time";
                    readonly description: "Start time of the throttle window";
                };
            };
            readonly required: readonly ["throttled"];
            readonly additionalProperties: false;
        };
    };
};

declare const delayRegularOutputSchema: {
    readonly type: "object";
    readonly properties: {
        readonly type: {
            readonly enum: readonly ["regular"];
        };
        readonly amount: {
            readonly type: "number";
        };
        readonly unit: {
            readonly type: "string";
            readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
        };
        readonly extendToSchedule: {
            readonly type: "boolean";
        };
    };
    readonly required: readonly ["amount", "unit"];
    readonly additionalProperties: false;
};
declare const delayTimedOutputSchema: {
    readonly type: "object";
    readonly properties: {
        readonly type: {
            readonly enum: readonly ["timed"];
        };
        readonly cron: {
            readonly type: "string";
        };
        readonly extendToSchedule: {
            readonly type: "boolean";
        };
    };
    readonly required: readonly ["cron"];
    readonly additionalProperties: false;
};
declare const delayDynamicOutputSchema: {
    readonly type: "object";
    readonly properties: {
        readonly type: {
            readonly enum: readonly ["dynamic"];
        };
        readonly dynamicKey: {
            readonly type: "string";
        };
        readonly extendToSchedule: {
            readonly type: "boolean";
        };
    };
    readonly required: readonly ["dynamicKey"];
    readonly additionalProperties: false;
};

declare const digestRegularOutputSchema: {
    readonly type: "object";
    readonly properties: {
        readonly type: {
            readonly enum: readonly ["regular"];
        };
        readonly amount: {
            readonly type: "number";
        };
        readonly unit: {
            readonly type: "string";
            readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
        };
        readonly digestKey: {
            readonly type: "string";
        };
        readonly lookBackWindow: {
            readonly type: "object";
            readonly properties: {
                readonly amount: {
                    readonly type: "number";
                };
                readonly unit: {
                    readonly type: "string";
                    readonly enum: readonly ["seconds", "minutes", "hours", "days", "weeks", "months"];
                };
            };
            readonly required: readonly ["amount", "unit"];
            readonly additionalProperties: false;
        };
        readonly extendToSchedule: {
            readonly type: "boolean";
        };
    };
    readonly required: readonly ["amount", "unit"];
    readonly additionalProperties: false;
};
declare const digestTimedOutputSchema: {
    readonly type: "object";
    readonly properties: {
        readonly type: {
            readonly enum: readonly ["timed"];
        };
        readonly cron: {
            readonly type: "string";
        };
        readonly digestKey: {
            readonly type: "string";
        };
        readonly extendToSchedule: {
            readonly type: "boolean";
        };
    };
    readonly required: readonly ["cron"];
    readonly additionalProperties: false;
};

declare const channelStepSchemas: {
    readonly chat: {
        output: {
            readonly type: "object";
            readonly properties: {
                readonly body: {
                    readonly type: "string";
                };
            };
            readonly required: readonly ["body"];
            readonly additionalProperties: false;
        };
        result: {
            readonly type: "object";
            readonly properties: {};
            readonly required: readonly [];
            readonly additionalProperties: false;
        };
    };
    readonly sms: {
        output: {
            readonly type: "object";
            readonly properties: {
                readonly body: {
                    readonly type: "string";
                };
            };
            readonly required: readonly ["body"];
            readonly additionalProperties: false;
        };
        result: {
            readonly type: "object";
            readonly properties: {};
            readonly required: readonly [];
            readonly additionalProperties: false;
        };
    };
    readonly push: {
        output: {
            readonly type: "object";
            readonly properties: {
                readonly subject: {
                    readonly type: "string";
                };
                readonly body: {
                    readonly type: "string";
                };
            };
            readonly required: readonly ["subject", "body"];
            readonly additionalProperties: false;
        };
        result: {
            readonly type: "object";
            readonly properties: {};
            readonly required: readonly [];
            readonly additionalProperties: false;
        };
    };
    readonly email: {
        output: {
            readonly type: "object";
            readonly properties: {
                readonly subject: {
                    readonly type: "string";
                    readonly minLength: 1;
                };
                readonly body: {
                    readonly type: "string";
                };
                readonly from: {
                    readonly type: "object";
                    readonly properties: {
                        readonly email: {
                            readonly type: "string";
                        };
                        readonly name: {
                            readonly type: "string";
                        };
                    };
                    readonly additionalProperties: false;
                };
            };
            readonly required: readonly ["subject", "body"];
            readonly additionalProperties: false;
        };
        result: {
            readonly type: "object";
            readonly properties: {};
            readonly required: readonly [];
            readonly additionalProperties: false;
        };
    };
    readonly in_app: {
        output: {
            readonly type: "object";
            readonly properties: {
                readonly subject: {
                    readonly type: "string";
                    readonly minLength: 1;
                };
                readonly body: {
                    readonly type: "string";
                    readonly minLength: 1;
                };
                readonly avatar: {
                    readonly type: "string";
                    readonly format: "uri";
                };
                readonly primaryAction: {
                    readonly type: "object";
                    readonly properties: {
                        readonly label: {
                            readonly type: "string";
                        };
                        readonly redirect: {
                            readonly type: "object";
                            readonly properties: {
                                readonly url: {
                                    readonly type: "string";
                                    readonly pattern: "^(?!mailto:)(?:(https?):\\/\\/[^\\s/$.?#].[^\\s]*)|^(\\/[^\\s]*)$";
                                };
                                readonly target: {
                                    readonly type: "string";
                                    readonly enum: readonly ["_self", "_blank", "_parent", "_top", "_unfencedTop"];
                                    readonly default: "_blank";
                                };
                            };
                            readonly if: {
                                readonly properties: {
                                    readonly url: {
                                        readonly type: "string";
                                        readonly pattern: "^/";
                                    };
                                };
                            };
                            readonly then: {
                                readonly properties: {
                                    readonly target: {
                                        readonly default: "_self";
                                    };
                                };
                            };
                            readonly else: {
                                readonly properties: {
                                    readonly target: {
                                        readonly default: "_blank";
                                    };
                                };
                            };
                            readonly required: readonly ["url"];
                            readonly additionalProperties: false;
                        };
                    };
                    readonly required: readonly ["label"];
                    readonly additionalProperties: false;
                };
                readonly secondaryAction: {
                    readonly type: "object";
                    readonly properties: {
                        readonly label: {
                            readonly type: "string";
                        };
                        readonly redirect: {
                            readonly type: "object";
                            readonly properties: {
                                readonly url: {
                                    readonly type: "string";
                                    readonly pattern: "^(?!mailto:)(?:(https?):\\/\\/[^\\s/$.?#].[^\\s]*)|^(\\/[^\\s]*)$";
                                };
                                readonly target: {
                                    readonly type: "string";
                                    readonly enum: readonly ["_self", "_blank", "_parent", "_top", "_unfencedTop"];
                                    readonly default: "_blank";
                                };
                            };
                            readonly if: {
                                readonly properties: {
                                    readonly url: {
                                        readonly type: "string";
                                        readonly pattern: "^/";
                                    };
                                };
                            };
                            readonly then: {
                                readonly properties: {
                                    readonly target: {
                                        readonly default: "_self";
                                    };
                                };
                            };
                            readonly else: {
                                readonly properties: {
                                    readonly target: {
                                        readonly default: "_blank";
                                    };
                                };
                            };
                            readonly required: readonly ["url"];
                            readonly additionalProperties: false;
                        };
                    };
                    readonly required: readonly ["label"];
                    readonly additionalProperties: false;
                };
                readonly data: {
                    readonly type: "object";
                    readonly additionalProperties: true;
                };
                readonly redirect: {
                    readonly type: "object";
                    readonly properties: {
                        readonly url: {
                            readonly type: "string";
                            readonly pattern: "^(?!mailto:)(?:(https?):\\/\\/[^\\s/$.?#].[^\\s]*)|^(\\/[^\\s]*)$";
                        };
                        readonly target: {
                            readonly type: "string";
                            readonly enum: readonly ["_self", "_blank", "_parent", "_top", "_unfencedTop"];
                            readonly default: "_blank";
                        };
                    };
                    readonly if: {
                        readonly properties: {
                            readonly url: {
                                readonly type: "string";
                                readonly pattern: "^/";
                            };
                        };
                    };
                    readonly then: {
                        readonly properties: {
                            readonly target: {
                                readonly default: "_self";
                            };
                        };
                    };
                    readonly else: {
                        readonly properties: {
                            readonly target: {
                                readonly default: "_blank";
                            };
                        };
                    };
                    readonly required: readonly ["url"];
                    readonly additionalProperties: false;
                };
            };
            readonly anyOf: [{
                readonly required: readonly ["subject"];
            }, {
                readonly required: readonly ["body"];
            }];
            readonly additionalProperties: false;
        };
        result: {
            readonly type: "object";
            readonly properties: {
                readonly seen: {
                    readonly type: "boolean";
                };
                readonly read: {
                    readonly type: "boolean";
                };
                readonly lastSeenDate: {
                    readonly type: "string";
                    readonly format: "date-time";
                    readonly nullable: true;
                };
                readonly lastReadDate: {
                    readonly type: "string";
                    readonly format: "date-time";
                    readonly nullable: true;
                };
            };
            readonly required: readonly ["seen", "read", "lastSeenDate", "lastReadDate"];
            readonly additionalProperties: false;
        };
    };
};

type Skip<T> = (controls: T) => Awaitable<boolean>;

type StepOptions<T_ControlSchema extends Schema = Schema, T_Controls extends Record<string, unknown> = FromSchema<T_ControlSchema>> = {
    /**
     * Skip the step. If the skip function returns true, the step will be skipped.
     *
     * @param controls The controls for the step.
     */
    skip?: Skip<T_Controls>;
    /**
     * The schema for the controls of the step. Used to validate the user-provided controls from Novu Dashboard.
     */
    controlSchema?: T_ControlSchema;
};
declare enum JobStatusEnum {
    PENDING = "pending",
    QUEUED = "queued",
    RUNNING = "running",
    COMPLETED = "completed",
    FAILED = "failed",
    DELAYED = "delayed",
    CANCELED = "canceled",
    MERGED = "merged",
    SKIPPED = "skipped"
}
type StepContext = {
    /** The context of the step. */
    _ctx: {
        /** The timestamp of the step. */
        timestamp: number;
        /** The state of the step. */
        state: {
            /** The status of the step. */
            status: `${JobStatusEnum}`;
            /** A boolean flag to indicate if the step has errored. */
            error: boolean;
        };
    };
};
type StepOutput<T_Result> = Promise<T_Result & StepContext>;
type ActionStep<T_Outputs extends Record<string, unknown> = Record<string, unknown>, T_Result extends Record<string, unknown> = Record<string, unknown>> = <
/**
 * The schema for the controls of the step.
 */
T_ControlSchema extends Schema, 
/**
 * The controls for the step.
 */
T_Controls extends Record<string, unknown> = FromSchema<T_ControlSchema>>(
/**
 * The name of the step. This is used to identify the step in the workflow.
 */
name: string, 
/**
 * The function to resolve the step notification content for the step.
 *
 * @param controls The controls for the step.
 */
resolve: (controls: T_Controls) => Awaitable<T_Outputs>, 
/**
 * The options for the step.
 */
options?: StepOptions<T_ControlSchema, T_Controls>) => StepOutput<T_Result>;
type CustomStep = <
/**
 * The schema for the controls of the step.
 */
T_ControlSchema extends Schema = Schema, 
/**
 * The schema for the outputs of the step.
 */
T_OutputsSchema extends Schema = Schema, 
/**
 * The controls for the step.
 */
T_Controls extends Record<string, unknown> = FromSchema<T_ControlSchema>, T_IntermediaryResult extends Record<string, unknown> = FromSchema<T_OutputsSchema>, T_IntermediaryOutput extends Record<string, unknown> = FromSchemaUnvalidated<T_OutputsSchema>, 
/**
 * The output for the step.
 */
T_Outputs extends T_IntermediaryOutput = T_IntermediaryOutput, 
/**
 * The result for the step.
 */
T_Result extends T_IntermediaryResult = T_IntermediaryResult>(
/**
 * The name of the step. This is used to identify the step in the workflow.
 */
name: string, 
/**
 * The function to resolve the custom data for the step.
 *
 * @param controls The controls for the step.
 */
resolve: (controls: T_Controls) => Awaitable<T_Outputs>, 
/**
 * The options for the step.
 */
options?: StepOptions<T_ControlSchema, T_Controls> & {
    /**
     * The schema for the outputs of the step. Used to validate the output of the `resolve` function.
     */
    outputSchema?: T_OutputsSchema;
}) => StepOutput<T_Result>;
type ChannelStep<
/**
 * The type of channel step.
 */
T_StepType extends keyof typeof channelStepSchemas = keyof typeof channelStepSchemas, 
/**
 * The outputs for the step.
 */
T_Outputs extends Record<string, unknown> = Record<string, unknown>, 
/**
 * The result for the step.
 */
T_Result extends Record<string, unknown> = Record<string, unknown>> = <
/**
 * The schema for the controls of the step.
 */
T_ControlSchema extends Schema, 
/**
 * The controls for the step.
 */
T_Controls extends Record<string, unknown> = FromSchema<T_ControlSchema>>(
/**
 * The name of the step. This is used to identify the step in the workflow.
 */
name: string, 
/**
 * The function to resolve the step notification content for the step.
 *
 * @param controls The controls for the step.
 */
resolve: (controls: T_Controls) => Awaitable<T_Outputs>, 
/**
 * The options for the step.
 */
options?: StepOptions<T_ControlSchema, T_Controls> & {
    /**
     * The providers for the step. Used to override the behaviour of the providers for the step.
     */
    providers?: Prettify<Providers<T_StepType, T_Controls, T_Outputs>>;
    /**
     * A flag to disable output sanitization for the step.
     *
     * @default false
     */
    disableOutputSanitization?: boolean;
}) => StepOutput<T_Result>;
type EmailOutput = FromSchema<(typeof channelStepSchemas)['email']['output']>;
type EmailOutputUnvalidated = FromSchemaUnvalidated<(typeof channelStepSchemas)['email']['output']>;
type EmailResult = FromSchema<(typeof channelStepSchemas)['email']['result']>;
type SmsOutput = FromSchema<(typeof channelStepSchemas)['sms']['output']>;
type SmsOutputUnvalidated = FromSchemaUnvalidated<(typeof channelStepSchemas)['sms']['output']>;
type SmsResult = FromSchema<(typeof channelStepSchemas)['sms']['result']>;
type PushOutput = FromSchema<(typeof channelStepSchemas)['push']['output']>;
type PushOutputUnvalidated = FromSchemaUnvalidated<(typeof channelStepSchemas)['push']['output']>;
type PushResult = FromSchema<(typeof channelStepSchemas)['push']['result']>;
type ChatOutput = FromSchema<(typeof channelStepSchemas)['chat']['output']>;
type ChatOutputUnvalidated = FromSchemaUnvalidated<(typeof channelStepSchemas)['chat']['output']>;
type ChatResult = FromSchema<(typeof channelStepSchemas)['chat']['result']>;
type InAppOutput = FromSchema<(typeof channelStepSchemas)['in_app']['output']>;
type InAppOutputUnvalidated = FromSchemaUnvalidated<(typeof channelStepSchemas)['in_app']['output']>;
type InAppResult = FromSchema<(typeof channelStepSchemas)['in_app']['result']>;
type DelayRegularOutput = FromSchema<typeof delayRegularOutputSchema>;
type DelayRegularOutputUnvalidated = FromSchemaUnvalidated<typeof delayRegularOutputSchema>;
type DelayTimedOutput = FromSchema<typeof delayTimedOutputSchema>;
type DelayTimedOutputUnvalidated = FromSchemaUnvalidated<typeof delayTimedOutputSchema>;
type DelayDynamicOutput = FromSchema<typeof delayDynamicOutputSchema>;
type DelayDynamicOutputUnvalidated = FromSchemaUnvalidated<typeof delayDynamicOutputSchema>;
type DelayOutput = FromSchema<(typeof actionStepSchemas)['delay']['output']>;
type DelayOutputUnvalidated = FromSchemaUnvalidated<(typeof actionStepSchemas)['delay']['output']>;
type DelayResult = FromSchema<(typeof actionStepSchemas)['delay']['result']>;
type DigestRegularOutput = FromSchema<typeof digestRegularOutputSchema>;
type DigestRegularOutputUnvalidated = FromSchemaUnvalidated<typeof digestRegularOutputSchema>;
type DigestTimedOutput = FromSchema<typeof digestTimedOutputSchema>;
type DigestTimedOutputUnvalidated = FromSchemaUnvalidated<typeof digestTimedOutputSchema>;
type DigestOutput = FromSchema<(typeof actionStepSchemas)['digest']['output']>;
type DigestOutputUnvalidated = FromSchemaUnvalidated<(typeof actionStepSchemas)['digest']['output']>;
type DigestResult = FromSchema<(typeof actionStepSchemas)['digest']['result']>;
type ThrottleOutput = FromSchema<(typeof actionStepSchemas)['throttle']['output']>;
type ThrottleOutputUnvalidated = FromSchemaUnvalidated<(typeof actionStepSchemas)['throttle']['output']>;
type ThrottleResult = FromSchema<(typeof actionStepSchemas)['throttle']['result']>;
/**
 * The step type.
 */
type Step = {
    /** Send an email. */
    email: ChannelStep<ChannelStepEnum.EMAIL, EmailOutputUnvalidated, EmailResult>;
    /** Send an SMS. */
    sms: ChannelStep<ChannelStepEnum.SMS, SmsOutputUnvalidated, SmsResult>;
    /** Send a push notification. */
    push: ChannelStep<ChannelStepEnum.PUSH, PushOutputUnvalidated, PushResult>;
    /** Send a chat message. */
    chat: ChannelStep<ChannelStepEnum.CHAT, ChatOutputUnvalidated, ChatResult>;
    /** Send an in-app notification. */
    inApp: ChannelStep<ChannelStepEnum.IN_APP, InAppOutputUnvalidated, InAppResult>;
    /** Aggregate events for a period of time. */
    digest: ActionStep<DigestOutputUnvalidated, DigestResult>;
    /** Delay the workflow for a period of time. */
    delay: ActionStep<DelayOutputUnvalidated, DelayResult>;
    /** Throttle workflow executions within a time window. */
    throttle: ActionStep<ThrottleOutputUnvalidated, ThrottleResult>;
    /** Execute custom code */
    custom: CustomStep;
};

type Subscriber = {
    subscriberId?: string;
    firstName?: string | null;
    lastName?: string | null;
    email?: string | null;
    phone?: string | null;
    avatar?: string | null;
    locale?: string | null;
    data?: Record<string, unknown> | null;
};

export { type Skip as $, ActionStepEnum as A, type DigestOutputUnvalidated as B, type ContextResolved as C, type DeepPartial as D, type Either as E, type DigestRegularOutput as F, type DigestRegularOutputUnvalidated as G, type DigestResult as H, type DigestTimedOutput as I, type DigestTimedOutputUnvalidated as J, type EmailOutput as K, type EmailOutputUnvalidated as L, type EmailResult as M, type InAppOutput as N, type InAppOutputUnvalidated as O, type PickRequiredKeys as P, type InAppResult as Q, type Indexable as R, type Subscriber as S, JobStatusEnum as T, type PickOptional as U, type PickOptionalKeys as V, type WithPassthrough as W, type PickRequired as X, type PushOutput as Y, type PushOutputUnvalidated as Z, type PushResult as _, type ContextPayload as a, type SmsOutput as a0, type SmsOutputUnvalidated as a1, type SmsResult as a2, type StepContext as a3, type StepOutput as a4, type ThrottleOutput as a5, type ThrottleOutputUnvalidated as a6, type ThrottleResult as a7, actionStepSchemas as a8, channelStepSchemas as a9, type ConditionalPartial as b, type Step as c, type Prettify as d, ChannelStepEnum as e, type Awaitable as f, type StepOptions as g, type ActionStep as h, type ChannelStep as i, type ChatOutput as j, type ChatOutputUnvalidated as k, type ChatResult as l, type ContextValue as m, type CustomStep as n, type DeepRequired as o, providerSchemas as p, type DelayDynamicOutput as q, type DelayDynamicOutputUnvalidated as r, type DelayOutput as s, type DelayOutputUnvalidated as t, type DelayRegularOutput as u, type DelayRegularOutputUnvalidated as v, type DelayResult as w, type DelayTimedOutput as x, type DelayTimedOutputUnvalidated as y, type DigestOutput as z };
