samva 0.16.0 → 0.17.0

package/dist/effect/generated/shared.d.ts

@@ -0,0 +1,3250 @@
+import type * as EffectBrand from "effect/Brand";
+import { HttpApiMiddleware, HttpApiSecurity } from "effect/http-api";
+import * as Schema from "effect/Schema";
+import { AbsoluteInstant as __SamvaRuntimeAbsoluteInstant, SensitiveString as __SamvaRuntimeSensitiveString } from "../runtime";
+export type JsonValue = string | number | boolean | null | ReadonlyArray<JsonValue> | {
+    readonly [x: string]: JsonValue;
+};
+export declare const JsonValue: Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>;
+declare const AnalyticsQueryError_base: Schema.Class<AnalyticsQueryError, Schema.Struct<{
+    readonly _tag: Schema.tag<"AnalyticsQueryError">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AnalyticsQueryError extends AnalyticsQueryError_base {
+}
+declare const UnauthorizedError_base: Schema.Class<UnauthorizedError, Schema.Struct<{
+    readonly _tag: Schema.tag<"UnauthorizedError">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnauthorizedError extends UnauthorizedError_base {
+}
+declare const ForbiddenError_base: Schema.Class<ForbiddenError, Schema.Struct<{
+    readonly _tag: Schema.tag<"ForbiddenError">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ForbiddenError extends ForbiddenError_base {
+}
+declare const ValidationError_base: Schema.Class<ValidationError, Schema.Struct<{
+    readonly _tag: Schema.tag<"ValidationError">;
+    readonly message: Schema.String;
+    readonly fields: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Null]>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ValidationError extends ValidationError_base {
+}
+declare const InternalError_base: Schema.Class<InternalError, Schema.Struct<{
+    readonly _tag: Schema.tag<"InternalError">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InternalError extends InternalError_base {
+}
+declare const GatewayTimeoutError_base: Schema.Class<GatewayTimeoutError, Schema.Struct<{
+    readonly _tag: Schema.tag<"GatewayTimeoutError">;
+    readonly message: Schema.String;
+    readonly retryAfterSeconds: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+export declare class GatewayTimeoutError extends GatewayTimeoutError_base {
+}
+export type Cursor = string;
+export declare const Cursor: Schema.String;
+export type ApiKeyResourceAccess = {
+    readonly messages?: "read" | "write" | null;
+    readonly email?: "read" | "write" | null;
+    readonly domains?: "read" | "write" | null;
+    readonly phoneNumbers?: "read" | "write" | null;
+    readonly contacts?: "read" | "write" | null;
+    readonly conversations?: "read" | "write" | null;
+    readonly templates?: "read" | "write" | null;
+    readonly webhooks?: "read" | "write" | null;
+    readonly apiKeys?: "read" | "write" | null;
+    readonly organization?: "read" | "write" | null;
+    readonly billing?: "read" | "write" | null;
+    readonly analytics?: "read" | "write" | null;
+};
+export declare const ApiKeyResourceAccess: Schema.Struct<{
+    readonly messages: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly email: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly domains: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly phoneNumbers: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly contacts: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly conversations: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly templates: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly webhooks: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly apiKeys: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly organization: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly billing: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    readonly analytics: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+}>;
+export type MailboxId = string & EffectBrand.Brand<"MailboxId">;
+export declare const MailboxId: Schema.brand<Schema.String, "MailboxId">;
+export type MailboxSendMode = "send" | "approval";
+export declare const MailboxSendMode: Schema.Union<readonly [Schema.Literal<"send">, Schema.Literal<"approval">]>;
+export type NamespaceId = string & EffectBrand.Brand<"NamespaceId">;
+export declare const NamespaceId: Schema.brand<Schema.String, "NamespaceId">;
+declare const PaymentRequiredError_base: Schema.Class<PaymentRequiredError, Schema.Struct<{
+    readonly _tag: Schema.tag<"PaymentRequiredError">;
+    readonly message: Schema.String;
+    readonly resource: Schema.String;
+    readonly currentUsage: Schema.Finite;
+    readonly limit: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+export declare class PaymentRequiredError extends PaymentRequiredError_base {
+}
+declare const ResourceNotFoundError_base: Schema.Class<ResourceNotFoundError, Schema.Struct<{
+    readonly _tag: Schema.tag<"ResourceNotFoundError">;
+    readonly resource: Schema.String;
+    readonly id: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResourceNotFoundError extends ResourceNotFoundError_base {
+}
+declare const RateLimitedError_base: Schema.Class<RateLimitedError, Schema.Struct<{
+    readonly _tag: Schema.tag<"RateLimitedError">;
+    readonly message: Schema.String;
+    readonly retryAfterSeconds: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+export declare class RateLimitedError extends RateLimitedError_base {
+}
+declare const BillingProviderError_base: Schema.Class<BillingProviderError, Schema.Struct<{
+    readonly _tag: Schema.tag<"BillingProviderError">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class BillingProviderError extends BillingProviderError_base {
+}
+export type ApiKeyId = string & EffectBrand.Brand<"ApiKeyId">;
+export declare const ApiKeyId: Schema.brand<Schema.String, "ApiKeyId">;
+export type SuccessResponse = {
+    readonly success: boolean;
+};
+export declare const SuccessResponse: Schema.Struct<{
+    readonly success: Schema.Boolean;
+}>;
+export type MessageId = string & EffectBrand.Brand<"MessageId">;
+export declare const MessageId: Schema.brand<Schema.String, "MessageId">;
+export type AttachmentId = string & EffectBrand.Brand<"AttachmentId">;
+export declare const AttachmentId: Schema.brand<Schema.String, "AttachmentId">;
+export type OrganizationId = string & EffectBrand.Brand<"OrganizationId">;
+export declare const OrganizationId: Schema.brand<Schema.String, "OrganizationId">;
+export type BrandAssets = {
+    readonly logoUrl?: string | null;
+    readonly logoDarkUrl?: string | null;
+    readonly iconUrl?: string | null;
+};
+export declare const BrandAssets: Schema.Struct<{
+    readonly logoUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly logoDarkUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly iconUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type BrandAddress = {
+    readonly street1: string;
+    readonly street2?: string | null;
+    readonly city: string;
+    readonly region: string;
+    readonly postalCode: string;
+    readonly country: string;
+};
+export declare const BrandAddress: Schema.Struct<{
+    readonly street1: Schema.String;
+    readonly street2: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly city: Schema.String;
+    readonly region: Schema.String;
+    readonly postalCode: Schema.String;
+    readonly country: Schema.String;
+}>;
+export type BrandSocialLink = {
+    readonly label: string;
+    readonly url: string;
+};
+export declare const BrandSocialLink: Schema.Struct<{
+    readonly label: Schema.String;
+    readonly url: Schema.String;
+}>;
+declare const ConflictError_base: Schema.Class<ConflictError, Schema.Struct<{
+    readonly _tag: Schema.tag<"ConflictError">;
+    readonly message: Schema.String;
+    readonly resource: Schema.String;
+    readonly id: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ConflictError extends ConflictError_base {
+}
+export type MediaId = string & EffectBrand.Brand<"MediaId">;
+export declare const MediaId: Schema.brand<Schema.String, "MediaId">;
+export type TemplatePublicationId = string & EffectBrand.Brand<"TemplatePublicationId">;
+export declare const TemplatePublicationId: Schema.brand<Schema.String, "TemplatePublicationId">;
+export type TemplateInputContractId = string & EffectBrand.Brand<"TemplateInputContractId">;
+export declare const TemplateInputContractId: Schema.brand<Schema.String, "TemplateInputContractId">;
+export type TemplateId = string & EffectBrand.Brand<"TemplateId">;
+export declare const TemplateId: Schema.brand<Schema.String, "TemplateId">;
+export type JsonObject = {
+    readonly [x: string]: JsonValue;
+};
+export declare const JsonObject: Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>;
+export type RenderLocale = string;
+export declare const RenderLocale: Schema.String;
+export type RenderTimeZone = string;
+export declare const RenderTimeZone: Schema.String;
+export type ReplyToAddresses = ReadonlyArray<string> | null | null;
+export declare const ReplyToAddresses: Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>, Schema.Null]>;
+export type UnsubscribeId = string & EffectBrand.Brand<"UnsubscribeId">;
+export declare const UnsubscribeId: Schema.brand<Schema.String, "UnsubscribeId">;
+export type EmailTrackingOverrideV1 = {
+    readonly opens?: boolean;
+    readonly clicks?: boolean;
+};
+export declare const EmailTrackingOverrideV1: Schema.Struct<{
+    readonly opens: Schema.optionalKey<Schema.Boolean>;
+    readonly clicks: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type EmailFooterOverride = {
+    readonly enabled?: boolean | null;
+};
+export declare const EmailFooterOverride: Schema.Struct<{
+    readonly enabled: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+}>;
+export type ConversationId = string & EffectBrand.Brand<"ConversationId">;
+export declare const ConversationId: Schema.brand<Schema.String, "ConversationId">;
+export type ContactId = string & EffectBrand.Brand<"ContactId">;
+export declare const ContactId: Schema.brand<Schema.String, "ContactId">;
+export type ContactGroupId = string & EffectBrand.Brand<"ContactGroupId">;
+export declare const ContactGroupId: Schema.brand<Schema.String, "ContactGroupId">;
+export type SendsSeries = ReadonlyArray<number>;
+export declare const SendsSeries: Schema.$Array<Schema.Finite>;
+declare const FlagDisabledError_base: Schema.Class<FlagDisabledError, Schema.Struct<{
+    readonly _tag: Schema.tag<"FlagDisabledError">;
+    readonly flag: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class FlagDisabledError extends FlagDisabledError_base {
+}
+export type EmailDomainId = string & EffectBrand.Brand<"EmailDomainId">;
+export declare const EmailDomainId: Schema.brand<Schema.String, "EmailDomainId">;
+declare const BrandAddressRequiredError_base: Schema.Class<BrandAddressRequiredError, Schema.Struct<{
+    readonly _tag: Schema.tag<"BrandAddressRequiredError">;
+    readonly message: Schema.String;
+    readonly brand: Schema.Union<readonly [Schema.String, Schema.Null]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class BrandAddressRequiredError extends BrandAddressRequiredError_base {
+}
+declare const CampaignFooterRequiredError_base: Schema.Class<CampaignFooterRequiredError, Schema.Struct<{
+    readonly _tag: Schema.tag<"CampaignFooterRequiredError">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class CampaignFooterRequiredError extends CampaignFooterRequiredError_base {
+}
+declare const ExternalServiceError_base: Schema.Class<ExternalServiceError, Schema.Struct<{
+    readonly _tag: Schema.tag<"ExternalServiceError">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExternalServiceError extends ExternalServiceError_base {
+}
+declare const SenderNotReadyError_base: Schema.Class<SenderNotReadyError, Schema.Struct<{
+    readonly _tag: Schema.tag<"SenderNotReadyError">;
+    readonly message: Schema.String;
+    readonly sender: Schema.String;
+    readonly retryAfterSeconds: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Null]>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class SenderNotReadyError extends SenderNotReadyError_base {
+}
+export type ContactIdentityId = string & EffectBrand.Brand<"ContactIdentityId">;
+export declare const ContactIdentityId: Schema.brand<Schema.String, "ContactIdentityId">;
+export type WebhookEndpointId = string & EffectBrand.Brand<"WebhookEndpointId">;
+export declare const WebhookEndpointId: Schema.brand<Schema.String, "WebhookEndpointId">;
+declare const EmailChannelError_base: Schema.Class<EmailChannelError, Schema.Struct<{
+    readonly _tag: Schema.tag<"EmailChannelError">;
+    readonly reason: Schema.Union<readonly [Schema.Literal<"transport">, Schema.Literal<"rejected">, Schema.Literal<"rate_limited">, Schema.Literal<"auth">]>;
+    readonly message: Schema.String;
+    readonly statusCode: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Null]>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class EmailChannelError extends EmailChannelError_base {
+}
+export type OperationId = string & EffectBrand.Brand<"OperationId">;
+export declare const OperationId: Schema.brand<Schema.String, "OperationId">;
+export type EmailSenderId = string & EffectBrand.Brand<"EmailSenderId">;
+export declare const EmailSenderId: Schema.brand<Schema.String, "EmailSenderId">;
+export type ExtensionId = string & EffectBrand.Brand<"ExtensionId">;
+export declare const ExtensionId: Schema.brand<Schema.String, "ExtensionId">;
+export type ExtensionVersionId = string & EffectBrand.Brand<"ExtensionVersionId">;
+export declare const ExtensionVersionId: Schema.brand<Schema.String, "ExtensionVersionId">;
+export type UserId = string & EffectBrand.Brand<"UserId">;
+export declare const UserId: Schema.brand<Schema.String, "UserId">;
+export type FeedbackContext = {
+    readonly operation?: string | null;
+    readonly resourceId?: string | null;
+};
+export declare const FeedbackContext: Schema.Struct<{
+    readonly operation: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly resourceId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type JourneyName = string;
+export declare const JourneyName: Schema.String;
+export type JourneyCustomEventName = string;
+export declare const JourneyCustomEventName: Schema.String;
+export type JourneyContactCreatedTrigger = {
+    readonly type: "contact.created";
+};
+export declare const JourneyContactCreatedTrigger: Schema.Struct<{
+    readonly type: Schema.Literal<"contact.created">;
+}>;
+export type JourneyTagAddedTrigger = {
+    readonly type: "contact.tag_added";
+    readonly tag: string;
+};
+export declare const JourneyTagAddedTrigger: Schema.Struct<{
+    readonly type: Schema.Literal<"contact.tag_added">;
+    readonly tag: Schema.String;
+}>;
+export type JourneyNodeId = string;
+export declare const JourneyNodeId: Schema.String;
+export type JourneyWaitConfig = {
+    readonly durationSeconds: number;
+};
+export declare const JourneyWaitConfig: Schema.Struct<{
+    readonly durationSeconds: Schema.Finite;
+}>;
+export type JourneyEmptyConfig = {
+    readonly [x: string]: never;
+};
+export declare const JourneyEmptyConfig: Schema.$Record<Schema.String, Schema.Never>;
+export type JourneyTagPredicate = {
+    readonly type: "tag";
+    readonly tag: string;
+    readonly present: boolean;
+};
+export declare const JourneyTagPredicate: Schema.Struct<{
+    readonly type: Schema.Literal<"tag">;
+    readonly tag: Schema.String;
+    readonly present: Schema.Boolean;
+}>;
+export type JourneyContactProperty = "name" | "displayName" | "externalId" | "status" | "profile.firstName" | "profile.lastName" | "profile.company" | "profile.jobTitle" | "profile.source" | "profile.location.country" | "profile.location.state" | "profile.location.city" | "profile.location.timezone";
+export declare const JourneyContactProperty: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+export type JourneyEqualityComparison = {
+    readonly operator: "eq" | "neq";
+    readonly value: string | number | boolean | null;
+};
+export declare const JourneyEqualityComparison: Schema.Struct<{
+    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+}>;
+export type JourneyNumericComparison = {
+    readonly operator: "gt" | "gte" | "lt" | "lte";
+    readonly value: number;
+};
+export declare const JourneyNumericComparison: Schema.Struct<{
+    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+    readonly value: Schema.Finite;
+}>;
+export type JourneyStringComparison = {
+    readonly operator: "contains" | "not_contains" | "starts_with" | "ends_with";
+    readonly value: string;
+};
+export declare const JourneyStringComparison: Schema.Struct<{
+    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+    readonly value: Schema.String;
+}>;
+export type JourneyPresenceComparison = {
+    readonly operator: "exists" | "not_exists";
+};
+export declare const JourneyPresenceComparison: Schema.Struct<{
+    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+}>;
+export type JourneyUpdateTagsConfig = {
+    readonly add: ReadonlyArray<string>;
+    readonly remove: ReadonlyArray<string>;
+};
+export declare const JourneyUpdateTagsConfig: Schema.Struct<{
+    readonly add: Schema.$Array<Schema.String>;
+    readonly remove: Schema.$Array<Schema.String>;
+}>;
+export type MailboxChannel = "email";
+export declare const MailboxChannel: Schema.Literal<"email">;
+export type MailboxMetadata = {
+    readonly [x: string]: string;
+};
+export declare const MailboxMetadata: Schema.$Record<Schema.String, Schema.String>;
+export type MailboxEndpointId = string & EffectBrand.Brand<"MailboxEndpointId">;
+export declare const MailboxEndpointId: Schema.brand<Schema.String, "MailboxEndpointId">;
+declare const MailboxChannelUnsupportedError_base: Schema.Class<MailboxChannelUnsupportedError, Schema.Struct<{
+    readonly _tag: Schema.tag<"MailboxChannelUnsupportedError">;
+    readonly message: Schema.String;
+    readonly channel: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class MailboxChannelUnsupportedError extends MailboxChannelUnsupportedError_base {
+}
+export type MailboxMetadataPatch = {
+    readonly [x: string]: string | null;
+};
+export declare const MailboxMetadataPatch: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Null]>>;
+export type MailboxThreadId = string & EffectBrand.Brand<"MailboxThreadId">;
+export declare const MailboxThreadId: Schema.brand<Schema.String, "MailboxThreadId">;
+export type MailboxActionId = string & EffectBrand.Brand<"MailboxActionId">;
+export declare const MailboxActionId: Schema.brand<Schema.String, "MailboxActionId">;
+export type MailboxDraftId = string & EffectBrand.Brand<"MailboxDraftId">;
+export declare const MailboxDraftId: Schema.brand<Schema.String, "MailboxDraftId">;
+export type MailboxPolicyId = string & EffectBrand.Brand<"MailboxPolicyId">;
+export declare const MailboxPolicyId: Schema.brand<Schema.String, "MailboxPolicyId">;
+export type MailboxSendError = {
+    readonly _tag: "SenderNotReadyError";
+    readonly message: string;
+    readonly sender: string;
+    readonly retryAfterSeconds?: number | null;
+} | {
+    readonly _tag: "RateLimitedError";
+    readonly message: string;
+    readonly retryAfterSeconds: number;
+} | {
+    readonly _tag: "OnboardingReviewRequiredError";
+    readonly message: string;
+    readonly code: "review_required" | "review_in_progress" | "information_required" | "review_rejected" | "identity_review_required" | "identity_review_rejected" | "identity_changed";
+    readonly decision: "undecided" | "approved" | "rejected";
+    readonly stage: "collecting" | "automated_review" | "manual_review" | "information_requested" | "complete";
+    readonly nextAction: "wait_for_review" | "provide_information" | "verify_sending_identity" | "reapply" | "contact_support";
+    readonly identityId?: string | null;
+} | {
+    readonly _tag: "PaymentRequiredError";
+    readonly message: string;
+    readonly resource: string;
+    readonly currentUsage: number;
+    readonly limit: number;
+} | {
+    readonly _tag: "ValidationError";
+    readonly message: string;
+    readonly fields?: {
+        readonly [x: string]: ReadonlyArray<string>;
+    } | null;
+} | {
+    readonly _tag: "ForbiddenError";
+    readonly message: string;
+} | {
+    readonly _tag: "ResourceNotFoundError";
+    readonly resource: string;
+    readonly id: string;
+    readonly message: string;
+};
+export declare const MailboxSendError: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"SenderNotReadyError">;
+    readonly message: Schema.String;
+    readonly sender: Schema.String;
+    readonly retryAfterSeconds: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Null]>>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"RateLimitedError">;
+    readonly message: Schema.String;
+    readonly retryAfterSeconds: Schema.Finite;
+}>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"OnboardingReviewRequiredError">;
+    readonly message: Schema.String;
+    readonly code: Schema.Union<readonly [Schema.Literal<"review_required">, Schema.Literal<"review_in_progress">, Schema.Literal<"information_required">, Schema.Literal<"review_rejected">, Schema.Literal<"identity_review_required">, Schema.Literal<"identity_review_rejected">, Schema.Literal<"identity_changed">]>;
+    readonly decision: Schema.Union<readonly [Schema.Literal<"undecided">, Schema.Literal<"approved">, Schema.Literal<"rejected">]>;
+    readonly stage: Schema.Union<readonly [Schema.Literal<"collecting">, Schema.Literal<"automated_review">, Schema.Literal<"manual_review">, Schema.Literal<"information_requested">, Schema.Literal<"complete">]>;
+    readonly nextAction: Schema.Union<readonly [Schema.Literal<"wait_for_review">, Schema.Literal<"provide_information">, Schema.Literal<"verify_sending_identity">, Schema.Literal<"reapply">, Schema.Literal<"contact_support">]>;
+    readonly identityId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"PaymentRequiredError">;
+    readonly message: Schema.String;
+    readonly resource: Schema.String;
+    readonly currentUsage: Schema.Finite;
+    readonly limit: Schema.Finite;
+}>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"ValidationError">;
+    readonly message: Schema.String;
+    readonly fields: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Null]>>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"ForbiddenError">;
+    readonly message: Schema.String;
+}>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"ResourceNotFoundError">;
+    readonly resource: Schema.String;
+    readonly id: Schema.String;
+    readonly message: Schema.String;
+}>]>;
+declare const OnboardingReviewRequiredError_base: Schema.Class<OnboardingReviewRequiredError, Schema.Struct<{
+    readonly _tag: Schema.tag<"OnboardingReviewRequiredError">;
+    readonly message: Schema.String;
+    readonly code: Schema.Union<readonly [Schema.Literal<"review_required">, Schema.Literal<"review_in_progress">, Schema.Literal<"information_required">, Schema.Literal<"review_rejected">, Schema.Literal<"identity_review_required">, Schema.Literal<"identity_review_rejected">, Schema.Literal<"identity_changed">]>;
+    readonly decision: Schema.Union<readonly [Schema.Literal<"undecided">, Schema.Literal<"approved">, Schema.Literal<"rejected">]>;
+    readonly stage: Schema.Union<readonly [Schema.Literal<"collecting">, Schema.Literal<"automated_review">, Schema.Literal<"manual_review">, Schema.Literal<"information_requested">, Schema.Literal<"complete">]>;
+    readonly nextAction: Schema.Union<readonly [Schema.Literal<"wait_for_review">, Schema.Literal<"provide_information">, Schema.Literal<"verify_sending_identity">, Schema.Literal<"reapply">, Schema.Literal<"contact_support">]>;
+    readonly identityId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>, import("effect/Cause").YieldableError>;
+export declare class OnboardingReviewRequiredError extends OnboardingReviewRequiredError_base {
+}
+export type MailboxThreadFolder = "inbox" | "assigned" | "pending" | "sent" | "archived" | "trash";
+export declare const MailboxThreadFolder: Schema.Union<readonly [Schema.Literal<"inbox">, Schema.Literal<"assigned">, Schema.Literal<"pending">, Schema.Literal<"sent">, Schema.Literal<"archived">, Schema.Literal<"trash">]>;
+export type MailboxGrantRole = "admin" | "collaborator" | "viewer";
+export declare const MailboxGrantRole: Schema.Union<readonly [Schema.Literal<"admin">, Schema.Literal<"collaborator">, Schema.Literal<"viewer">]>;
+export type MailboxLabelId = string & EffectBrand.Brand<"MailboxLabelId">;
+export declare const MailboxLabelId: Schema.brand<Schema.String, "MailboxLabelId">;
+export type MailboxPolicyOutcomeKind = "requireApproval" | "deny";
+export declare const MailboxPolicyOutcomeKind: Schema.Union<readonly [Schema.Literal<"requireApproval">, Schema.Literal<"deny">]>;
+export type MailboxThreadPriority = "low" | "normal" | "high" | "urgent";
+export declare const MailboxThreadPriority: Schema.Union<readonly [Schema.Literal<"low">, Schema.Literal<"normal">, Schema.Literal<"high">, Schema.Literal<"urgent">]>;
+export type MessageMetadata = {
+    readonly [x: string]: JsonValue;
+} | null;
+export declare const MessageMetadata: Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>;
+export type EmailSender = {
+    readonly email: string;
+    readonly name?: string | null;
+} | null;
+export declare const EmailSender: Schema.Union<readonly [Schema.Struct<{
+    readonly email: Schema.String;
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>, Schema.Null]>;
+declare const DeliveryUnavailableError_base: Schema.Class<DeliveryUnavailableError, Schema.Struct<{
+    readonly _tag: Schema.tag<"DeliveryUnavailableError">;
+    readonly message: Schema.String;
+    readonly retryAfterSeconds: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+export declare class DeliveryUnavailableError extends DeliveryUnavailableError_base {
+}
+export type IanaTimezone = string;
+export declare const IanaTimezone: Schema.String;
+export type NamespaceMetadata = {
+    readonly [x: string]: string;
+};
+export declare const NamespaceMetadata: Schema.$Record<Schema.String, Schema.String>;
+export type OperationResource = {
+    readonly type: string;
+    readonly id: string;
+};
+export declare const OperationResource: Schema.Struct<{
+    readonly type: Schema.String;
+    readonly id: Schema.String;
+}>;
+export type TemplateFromDefault = {
+    readonly email: string;
+    readonly name?: string | null;
+};
+export declare const TemplateFromDefault: Schema.Struct<{
+    readonly email: Schema.String;
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type AddTemplateEntryPayload = {
+    readonly entryPath: string;
+    readonly name: string;
+    readonly slug: string;
+    readonly description?: string | null | null;
+    readonly category?: "transactional" | "marketing" | "support" | "notification" | "verification" | "reminder" | "alert" | null | null;
+};
+export declare const AddTemplateEntryPayload: Schema.Struct<{
+    readonly entryPath: Schema.String;
+    readonly name: Schema.String;
+    readonly slug: Schema.String;
+    readonly description: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    readonly category: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"transactional">, Schema.Literal<"marketing">, Schema.Literal<"support">, Schema.Literal<"notification">, Schema.Literal<"verification">, Schema.Literal<"reminder">, Schema.Literal<"alert">]>, Schema.Null]>, Schema.Null]>>;
+}>;
+export type ContactTags = {
+    readonly tags: readonly [string, ...Array<string>];
+};
+export declare const ContactTags: Schema.Struct<{
+    readonly tags: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.String]>, readonly [Schema.String]>;
+}>;
+export type ConversationCategories = {
+    readonly categories: readonly [string, ...Array<string>];
+};
+export declare const ConversationCategories: Schema.Struct<{
+    readonly categories: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.String]>, readonly [Schema.String]>;
+}>;
+export type ConversationChannels = {
+    readonly channels: readonly ["email", ...Array<"email">];
+};
+export declare const ConversationChannels: Schema.Struct<{
+    readonly channels: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Literal<"email">]>, readonly [Schema.Literal<"email">]>;
+}>;
+export type ConversationTags = {
+    readonly tags: readonly [string, ...Array<string>];
+};
+export declare const ConversationTags: Schema.Struct<{
+    readonly tags: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.String]>, readonly [Schema.String]>;
+}>;
+export type CreateDomainWarmingPlanPayload = {
+    readonly identity: "new" | "migrating" | "returning";
+    readonly initialDailyRecipients: number;
+    readonly dailyGrowthPercent: number;
+    readonly targetDailyRecipients: number;
+};
+export declare const CreateDomainWarmingPlanPayload: Schema.Struct<{
+    readonly identity: Schema.Union<readonly [Schema.Literal<"new">, Schema.Literal<"migrating">, Schema.Literal<"returning">]>;
+    readonly initialDailyRecipients: Schema.Finite;
+    readonly dailyGrowthPercent: Schema.Finite;
+    readonly targetDailyRecipients: Schema.Finite;
+}>;
+export type CreateMailboxLabelPayload = {
+    readonly slug: string;
+    readonly displayName: string;
+    readonly color?: "billing" | "domain" | "agent" | "routing" | "important" | "neutral" | null | null;
+};
+export declare const CreateMailboxLabelPayload: Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly displayName: Schema.String;
+    readonly color: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"billing">, Schema.Literal<"domain">, Schema.Literal<"agent">, Schema.Literal<"routing">, Schema.Literal<"important">, Schema.Literal<"neutral">]>, Schema.Null]>, Schema.Null]>>;
+}>;
+export type CreateMailboxNotePayload = {
+    readonly body: string;
+    readonly color?: string | null | null;
+    readonly pinned?: boolean | null;
+};
+export declare const CreateMailboxNotePayload: Schema.Struct<{
+    readonly body: Schema.String;
+    readonly color: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    readonly pinned: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+}>;
+export type CreateMediaPayload = {
+    readonly filename: string;
+    readonly contentType: string;
+    readonly sizeBytes: number;
+    readonly purpose: "attachment" | "avatar" | "review_evidence";
+    readonly checksumSha256?: string | null;
+};
+export declare const CreateMediaPayload: Schema.Struct<{
+    readonly filename: Schema.String;
+    readonly contentType: Schema.String;
+    readonly sizeBytes: Schema.Finite;
+    readonly purpose: Schema.Union<readonly [Schema.Literal<"attachment">, Schema.Literal<"avatar">, Schema.Literal<"review_evidence">]>;
+    readonly checksumSha256: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type CreateTemplatePayload = {
+    readonly name: string;
+    readonly projectName?: string | null;
+    readonly slug?: string | null;
+    readonly galleryTemplateId?: string | null;
+    readonly useBrand?: boolean | null;
+    readonly description?: string | null | null;
+    readonly category?: "transactional" | "marketing" | "support" | "notification" | "verification" | "reminder" | "alert" | null | null;
+    readonly isActive?: boolean | null;
+    readonly idempotencyKey: string;
+};
+export declare const CreateTemplatePayload: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly projectName: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly slug: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly galleryTemplateId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly useBrand: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+    readonly description: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    readonly category: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"transactional">, Schema.Literal<"marketing">, Schema.Literal<"support">, Schema.Literal<"notification">, Schema.Literal<"verification">, Schema.Literal<"reminder">, Schema.Literal<"alert">]>, Schema.Null]>, Schema.Null]>>;
+    readonly isActive: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+    readonly idempotencyKey: Schema.String;
+}>;
+export type DenyMailboxActionPayload = {
+    readonly reason: string;
+};
+export declare const DenyMailboxActionPayload: Schema.Struct<{
+    readonly reason: Schema.String;
+}>;
+export type DomainWarmingNotePayload = {
+    readonly note?: string | null;
+};
+export declare const DomainWarmingNotePayload: Schema.Struct<{
+    readonly note: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type PublishExtensionVersionPayload = {
+    readonly manifest: {
+        readonly name: string;
+        readonly displayName: string;
+        readonly description?: string | null;
+        readonly version: string;
+        readonly runtime: "hosted" | "webhook";
+        readonly events: ReadonlyArray<"mailbox.message.received" | "mailbox.message.sent" | "mailbox.action.pending_approval" | "mailbox.message.quarantined" | "mailbox.message.released" | "mailbox.message.discarded">;
+        readonly permissions: ReadonlyArray<"read" | "update" | "send" | "quarantine.read">;
+    };
+    readonly bundle?: string | null;
+};
+export declare const PublishExtensionVersionPayload: Schema.Struct<{
+    readonly manifest: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly displayName: Schema.String;
+        readonly description: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly version: Schema.String;
+        readonly runtime: Schema.Union<readonly [Schema.Literal<"hosted">, Schema.Literal<"webhook">]>;
+        readonly events: Schema.$Array<Schema.Union<readonly [Schema.Literal<"mailbox.message.received">, Schema.Literal<"mailbox.message.sent">, Schema.Literal<"mailbox.action.pending_approval">, Schema.Literal<"mailbox.message.quarantined">, Schema.Literal<"mailbox.message.released">, Schema.Literal<"mailbox.message.discarded">]>>;
+        readonly permissions: Schema.$Array<Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"update">, Schema.Literal<"send">, Schema.Literal<"quarantine.read">]>>;
+    }>;
+    readonly bundle: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type PublishJourneyPayload = {
+    readonly revision: string;
+};
+export declare const PublishJourneyPayload: Schema.Struct<{
+    readonly revision: Schema.String;
+}>;
+export type ReapplyOnboardingReviewInput = {
+    readonly expectedGeneration: number;
+};
+export declare const ReapplyOnboardingReviewInput: Schema.Struct<{
+    readonly expectedGeneration: Schema.Finite;
+}>;
+export type TemplateFamilyName = {
+    readonly name: string;
+};
+export declare const TemplateFamilyName: Schema.Struct<{
+    readonly name: Schema.String;
+}>;
+export type TestWebhookPayload = {
+    readonly data?: {
+        readonly [x: string]: JsonValue;
+    } | null;
+};
+export declare const TestWebhookPayload: Schema.Struct<{
+    readonly data: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>>;
+}>;
+export type UpdateDomainWarmingPolicyPayload = {
+    readonly dailyGrowthPercent: number;
+    readonly targetDailyRecipients: number;
+    readonly note?: string | null;
+};
+export declare const UpdateDomainWarmingPolicyPayload: Schema.Struct<{
+    readonly dailyGrowthPercent: Schema.Finite;
+    readonly targetDailyRecipients: Schema.Finite;
+    readonly note: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type UpdateMailboxEndpointPayload = {
+    readonly displayName?: string | null | null;
+    readonly default?: true | null;
+};
+export declare const UpdateMailboxEndpointPayload: Schema.Struct<{
+    readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    readonly default: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<true>, Schema.Null]>>;
+}>;
+export type UpdateMailboxLabelPayload = {
+    readonly displayName?: string | null;
+    readonly color?: "billing" | "domain" | "agent" | "routing" | "important" | "neutral" | null | null;
+};
+export declare const UpdateMailboxLabelPayload: Schema.Struct<{
+    readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly color: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"billing">, Schema.Literal<"domain">, Schema.Literal<"agent">, Schema.Literal<"routing">, Schema.Literal<"important">, Schema.Literal<"neutral">]>, Schema.Null]>, Schema.Null]>>;
+}>;
+export type UpdateMailboxNotePayload = {
+    readonly body?: string | null;
+    readonly color?: string | null | null;
+    readonly pinned?: boolean | null;
+};
+export declare const UpdateMailboxNotePayload: Schema.Struct<{
+    readonly body: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly color: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    readonly pinned: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+}>;
+export type UpdateNamespacePayload = {
+    readonly name?: string | null;
+    readonly metadata?: {
+        readonly [x: string]: string | null;
+    } | null;
+};
+export declare const UpdateNamespacePayload: Schema.Struct<{
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly metadata: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Null]>>, Schema.Null]>>;
+}>;
+export type ApiKeyMailboxAccess = {
+    readonly permissions: readonly [
+        "read" | "update" | "send" | "quarantine.read",
+        ...Array<"read" | "update" | "send" | "quarantine.read">
+    ];
+    readonly mailboxIds?: readonly [MailboxId, ...Array<MailboxId>] | null;
+    readonly sendMode?: MailboxSendMode | null;
+};
+export declare const ApiKeyMailboxAccess: Schema.Struct<{
+    readonly permissions: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"update">, Schema.Literal<"send">, Schema.Literal<"quarantine.read">]>]>, readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"update">, Schema.Literal<"send">, Schema.Literal<"quarantine.read">]>]>;
+    readonly mailboxIds: Schema.optionalKey<Schema.Union<readonly [Schema.TupleWithRest<Schema.Tuple<readonly [Schema.brand<Schema.String, "MailboxId">]>, readonly [Schema.brand<Schema.String, "MailboxId">]>, Schema.Null]>>;
+    readonly sendMode: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"send">, Schema.Literal<"approval">]>, Schema.Null]>>;
+}>;
+export type CreateWebhookPayload = {
+    readonly name: string;
+    readonly url: string;
+    readonly eventTypes: ReadonlyArray<"message.sent" | "message.delivered" | "message.read" | "message.failed" | "message.bounced" | "message.complained" | "message.received" | "message.opened" | "message.clicked" | "contact.created" | "contact.updated" | "contact.deleted" | "contact.subscribed" | "contact.unsubscribed" | "contact.resubscribed" | "conversation.created" | "conversation.updated" | "conversation.archived" | "webhook.created" | "webhook.updated" | "webhook.deleted" | "webhook.test" | "domain.updated" | "domain.warming.updated" | "mailbox.message.received" | "mailbox.message.sent" | "mailbox.action.pending_approval" | "mailbox.message.quarantined" | "mailbox.message.released" | "mailbox.message.discarded" | "journey.webhook">;
+    readonly channels?: ReadonlyArray<"email"> | null;
+    readonly mailboxIds?: readonly [MailboxId, ...Array<MailboxId>] | null;
+    readonly namespaceId?: NamespaceId | null;
+    readonly headers?: {
+        readonly [x: string]: string;
+    } | null;
+    readonly status?: "active" | "disabled" | null;
+};
+export declare const CreateWebhookPayload: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly url: Schema.String;
+    readonly eventTypes: Schema.$Array<Schema.Union<readonly [Schema.Literal<"message.sent">, Schema.Literal<"message.delivered">, Schema.Literal<"message.read">, Schema.Literal<"message.failed">, Schema.Literal<"message.bounced">, Schema.Literal<"message.complained">, Schema.Literal<"message.received">, Schema.Literal<"message.opened">, Schema.Literal<"message.clicked">, Schema.Literal<"contact.created">, Schema.Literal<"contact.updated">, Schema.Literal<"contact.deleted">, Schema.Literal<"contact.subscribed">, Schema.Literal<"contact.unsubscribed">, Schema.Literal<"contact.resubscribed">, Schema.Literal<"conversation.created">, Schema.Literal<"conversation.updated">, Schema.Literal<"conversation.archived">, Schema.Literal<"webhook.created">, Schema.Literal<"webhook.updated">, Schema.Literal<"webhook.deleted">, Schema.Literal<"webhook.test">, Schema.Literal<"domain.updated">, Schema.Literal<"domain.warming.updated">, Schema.Literal<"mailbox.message.received">, Schema.Literal<"mailbox.message.sent">, Schema.Literal<"mailbox.action.pending_approval">, Schema.Literal<"mailbox.message.quarantined">, Schema.Literal<"mailbox.message.released">, Schema.Literal<"mailbox.message.discarded">, Schema.Literal<"journey.webhook">]>>;
+    readonly channels: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Literal<"email">>, Schema.Null]>>;
+    readonly mailboxIds: Schema.optionalKey<Schema.Union<readonly [Schema.TupleWithRest<Schema.Tuple<readonly [Schema.brand<Schema.String, "MailboxId">]>, readonly [Schema.brand<Schema.String, "MailboxId">]>, Schema.Null]>>;
+    readonly namespaceId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "NamespaceId">, Schema.Null]>>;
+    readonly headers: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.String>, Schema.Null]>>;
+    readonly status: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"active">, Schema.Literal<"disabled">]>, Schema.Null]>>;
+}>;
+export type InstallExtensionPayload = {
+    readonly extension: string;
+    readonly version?: string | null;
+    readonly mailboxIds?: ReadonlyArray<MailboxId> | null;
+    readonly namespaceId?: NamespaceId | null;
+    readonly permissions?: ReadonlyArray<"read" | "update" | "send" | "quarantine.read"> | null;
+    readonly sendMode?: "send" | "approval" | null;
+    readonly webhookUrl?: string | null;
+};
+export declare const InstallExtensionPayload: Schema.Struct<{
+    readonly extension: Schema.String;
+    readonly version: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly mailboxIds: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.brand<Schema.String, "MailboxId">>, Schema.Null]>>;
+    readonly namespaceId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "NamespaceId">, Schema.Null]>>;
+    readonly permissions: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"update">, Schema.Literal<"send">, Schema.Literal<"quarantine.read">]>>, Schema.Null]>>;
+    readonly sendMode: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"send">, Schema.Literal<"approval">]>, Schema.Null]>>;
+    readonly webhookUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type UpdateWebhookPayload = {
+    readonly name?: string | null;
+    readonly url?: string | null;
+    readonly eventTypes?: ReadonlyArray<"message.sent" | "message.delivered" | "message.read" | "message.failed" | "message.bounced" | "message.complained" | "message.received" | "message.opened" | "message.clicked" | "contact.created" | "contact.updated" | "contact.deleted" | "contact.subscribed" | "contact.unsubscribed" | "contact.resubscribed" | "conversation.created" | "conversation.updated" | "conversation.archived" | "webhook.created" | "webhook.updated" | "webhook.deleted" | "webhook.test" | "domain.updated" | "domain.warming.updated" | "mailbox.message.received" | "mailbox.message.sent" | "mailbox.action.pending_approval" | "mailbox.message.quarantined" | "mailbox.message.released" | "mailbox.message.discarded" | "journey.webhook"> | null;
+    readonly channels?: ReadonlyArray<"email"> | null | null;
+    readonly mailboxIds?: readonly [MailboxId, ...Array<MailboxId>] | null | null;
+    readonly namespaceId?: NamespaceId | null | null;
+    readonly headers?: {
+        readonly [x: string]: string;
+    } | null;
+    readonly status?: "active" | "disabled" | null;
+};
+export declare const UpdateWebhookPayload: Schema.Struct<{
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly url: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly eventTypes: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Union<readonly [Schema.Literal<"message.sent">, Schema.Literal<"message.delivered">, Schema.Literal<"message.read">, Schema.Literal<"message.failed">, Schema.Literal<"message.bounced">, Schema.Literal<"message.complained">, Schema.Literal<"message.received">, Schema.Literal<"message.opened">, Schema.Literal<"message.clicked">, Schema.Literal<"contact.created">, Schema.Literal<"contact.updated">, Schema.Literal<"contact.deleted">, Schema.Literal<"contact.subscribed">, Schema.Literal<"contact.unsubscribed">, Schema.Literal<"contact.resubscribed">, Schema.Literal<"conversation.created">, Schema.Literal<"conversation.updated">, Schema.Literal<"conversation.archived">, Schema.Literal<"webhook.created">, Schema.Literal<"webhook.updated">, Schema.Literal<"webhook.deleted">, Schema.Literal<"webhook.test">, Schema.Literal<"domain.updated">, Schema.Literal<"domain.warming.updated">, Schema.Literal<"mailbox.message.received">, Schema.Literal<"mailbox.message.sent">, Schema.Literal<"mailbox.action.pending_approval">, Schema.Literal<"mailbox.message.quarantined">, Schema.Literal<"mailbox.message.released">, Schema.Literal<"mailbox.message.discarded">, Schema.Literal<"journey.webhook">]>>, Schema.Null]>>;
+    readonly channels: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.Literal<"email">>, Schema.Null]>, Schema.Null]>>;
+    readonly mailboxIds: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.TupleWithRest<Schema.Tuple<readonly [Schema.brand<Schema.String, "MailboxId">]>, readonly [Schema.brand<Schema.String, "MailboxId">]>, Schema.Null]>, Schema.Null]>>;
+    readonly namespaceId: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.String, "NamespaceId">, Schema.Null]>, Schema.Null]>>;
+    readonly headers: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.String>, Schema.Null]>>;
+    readonly status: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"active">, Schema.Literal<"disabled">]>, Schema.Null]>>;
+}>;
+export type MessageSummary = {
+    readonly id: MessageId;
+    readonly channel: "email";
+    readonly direction: "outbound" | "inbound";
+    readonly status: "pending" | "scheduled" | "queued" | "processing" | "sent" | "delivered" | "read" | "failed" | "bounced" | "complained";
+    readonly from: string | null;
+    readonly to: ReadonlyArray<string>;
+    readonly subject: string | null;
+    readonly waitReason: "rate" | "daily-quota" | "domain-health" | "sending-paused" | "upstream-unavailable" | "retry" | "campaign-paused" | "domain-warming" | "onboarding-review" | "content-review" | "screening-unavailable" | null;
+    readonly createdAt: string;
+};
+export declare const MessageSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "MessageId">;
+    readonly channel: Schema.Literal<"email">;
+    readonly direction: Schema.Union<readonly [Schema.Literal<"outbound">, Schema.Literal<"inbound">]>;
+    readonly status: Schema.Union<readonly [Schema.Literal<"pending">, Schema.Literal<"scheduled">, Schema.Literal<"queued">, Schema.Literal<"processing">, Schema.Literal<"sent">, Schema.Literal<"delivered">, Schema.Literal<"read">, Schema.Literal<"failed">, Schema.Literal<"bounced">, Schema.Literal<"complained">]>;
+    readonly from: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly to: Schema.$Array<Schema.String>;
+    readonly subject: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly waitReason: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"rate">, Schema.Literal<"daily-quota">, Schema.Literal<"domain-health">, Schema.Literal<"sending-paused">, Schema.Literal<"upstream-unavailable">, Schema.Literal<"retry">, Schema.Literal<"campaign-paused">, Schema.Literal<"domain-warming">, Schema.Literal<"onboarding-review">, Schema.Literal<"content-review">, Schema.Literal<"screening-unavailable">]>, Schema.Null]>;
+    readonly createdAt: Schema.String;
+}>;
+export type BrandFooter = {
+    readonly companyName?: string | null;
+    readonly address?: BrandAddress | null;
+    readonly socialLinks?: ReadonlyArray<BrandSocialLink> | null;
+};
+export declare const BrandFooter: Schema.Struct<{
+    readonly companyName: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly address: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly street1: Schema.String;
+        readonly street2: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly city: Schema.String;
+        readonly region: Schema.String;
+        readonly postalCode: Schema.String;
+        readonly country: Schema.String;
+    }>, Schema.Null]>>;
+    readonly socialLinks: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+        readonly label: Schema.String;
+        readonly url: Schema.String;
+    }>>, Schema.Null]>>;
+}>;
+export type EmailAttachment = {
+    readonly filename: string;
+    readonly content?: string | null;
+    readonly mediaId?: MediaId | null;
+    readonly contentType: string;
+    readonly size: number;
+};
+export declare const EmailAttachment: Schema.Struct<{
+    readonly filename: Schema.String;
+    readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+    readonly contentType: Schema.String;
+    readonly size: Schema.Finite;
+}>;
+export type RespondToOnboardingInformationRequestInput = {
+    readonly expectedGeneration: number;
+    readonly responseText: string;
+    readonly evidenceMediaIds: ReadonlyArray<MediaId>;
+};
+export declare const RespondToOnboardingInformationRequestInput: Schema.Struct<{
+    readonly expectedGeneration: Schema.Finite;
+    readonly responseText: Schema.String;
+    readonly evidenceMediaIds: Schema.$Array<Schema.brand<Schema.String, "MediaId">>;
+}>;
+export type TemplateData = JsonObject | null;
+export declare const TemplateData: Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>;
+export type JourneyWebhookConfig = {
+    readonly data?: JsonObject;
+};
+export declare const JourneyWebhookConfig: Schema.Struct<{
+    readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+}>;
+export type RenderTemplatePublicationPayload = {
+    readonly data: {
+        readonly [x: string]: JsonValue;
+    };
+    readonly locale?: RenderLocale;
+    readonly timeZone?: RenderTimeZone;
+};
+export declare const RenderTemplatePublicationPayload: Schema.Struct<{
+    readonly data: Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>;
+    readonly locale: Schema.optionalKey<Schema.String>;
+    readonly timeZone: Schema.optionalKey<Schema.String>;
+}>;
+export type SkippedRecipient = {
+    readonly address: string;
+    readonly reason: "bounce" | "complaint" | "unsubscribe" | "manual" | "group-unsubscribe";
+    readonly unsubscribeGroupId?: UnsubscribeId | null;
+};
+export declare const SkippedRecipient: Schema.Struct<{
+    readonly address: Schema.String;
+    readonly reason: Schema.Union<readonly [Schema.Literal<"bounce">, Schema.Literal<"complaint">, Schema.Literal<"unsubscribe">, Schema.Literal<"manual">, Schema.Literal<"group-unsubscribe">]>;
+    readonly unsubscribeGroupId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "UnsubscribeId">, Schema.Null]>>;
+}>;
+export type ContactEvent = {
+    readonly id: string;
+    readonly contactId: ContactId;
+    readonly name: string;
+    readonly source: "api" | "samva";
+    readonly properties: JsonObject;
+    readonly occurredAt: string;
+    readonly recordedAt: string;
+};
+export declare const ContactEvent: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly contactId: Schema.brand<Schema.String, "ContactId">;
+    readonly name: Schema.String;
+    readonly source: Schema.Union<readonly [Schema.Literal<"api">, Schema.Literal<"samva">]>;
+    readonly properties: Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>;
+    readonly occurredAt: Schema.String;
+    readonly recordedAt: Schema.String;
+}>;
+export type ContactEventReference = {
+    readonly id: ContactId;
+    readonly externalId?: never;
+    readonly email?: never;
+} | {
+    readonly externalId: string;
+    readonly id?: never;
+    readonly email?: never;
+} | {
+    readonly email: string;
+    readonly id?: never;
+    readonly externalId?: never;
+};
+export declare const ContactEventReference: Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ContactId">;
+    readonly externalId: Schema.optionalKey<Schema.Never>;
+    readonly email: Schema.optionalKey<Schema.Never>;
+}>, Schema.Struct<{
+    readonly externalId: Schema.String;
+    readonly id: Schema.optionalKey<Schema.Never>;
+    readonly email: Schema.optionalKey<Schema.Never>;
+}>, Schema.Struct<{
+    readonly email: Schema.String;
+    readonly id: Schema.optionalKey<Schema.Never>;
+    readonly externalId: Schema.optionalKey<Schema.Never>;
+}>]>;
+export type EmailRecipient = {
+    readonly contactId: ContactId;
+} | {
+    readonly email: string;
+    readonly name?: string | null;
+    readonly displayName?: string | null | null;
+};
+export declare const EmailRecipient: Schema.Union<readonly [Schema.Struct<{
+    readonly contactId: Schema.brand<Schema.String, "ContactId">;
+}>, Schema.Struct<{
+    readonly email: Schema.String;
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+}>]>;
+export type ConversationContacts = {
+    readonly contactIds: readonly [ContactId, ...Array<ContactId>];
+};
+export declare const ConversationContacts: Schema.Struct<{
+    readonly contactIds: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.brand<Schema.String, "ContactId">]>, readonly [Schema.brand<Schema.String, "ContactId">]>;
+}>;
+export type JourneyGroupJoinedTrigger = {
+    readonly type: "contact.joined_group";
+    readonly groupId: ContactGroupId;
+};
+export declare const JourneyGroupJoinedTrigger: Schema.Struct<{
+    readonly type: Schema.Literal<"contact.joined_group">;
+    readonly groupId: Schema.brand<Schema.String, "ContactGroupId">;
+}>;
+export type SubscribePayload = {
+    readonly email: string;
+    readonly contactGroupId: ContactGroupId;
+    readonly from: {
+        readonly email: string;
+        readonly name?: string | null;
+    };
+    readonly unsubscribeGroupId?: UnsubscribeId | null;
+    readonly templateSlug?: string | null;
+    readonly consentIp?: string | null;
+    readonly consentSource?: string | null;
+};
+export declare const SubscribePayload: Schema.Struct<{
+    readonly email: Schema.String;
+    readonly contactGroupId: Schema.brand<Schema.String, "ContactGroupId">;
+    readonly from: Schema.Struct<{
+        readonly email: Schema.String;
+        readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>;
+    readonly unsubscribeGroupId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "UnsubscribeId">, Schema.Null]>>;
+    readonly templateSlug: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly consentIp: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly consentSource: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type ContactIdentity = {
+    readonly id: ContactIdentityId;
+    readonly channel: "email";
+    readonly identifier: string;
+    readonly verified: boolean;
+};
+export declare const ContactIdentity: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ContactIdentityId">;
+    readonly channel: Schema.Literal<"email">;
+    readonly identifier: Schema.String;
+    readonly verified: Schema.Boolean;
+}>;
+export type JourneySendEmailConfig = {
+    readonly template: TemplateId | string;
+    readonly senderId?: EmailSenderId;
+    readonly templateData?: JsonObject;
+};
+export declare const JourneySendEmailConfig: Schema.Struct<{
+    readonly template: Schema.Union<readonly [Schema.brand<Schema.String, "TemplateId">, Schema.String]>;
+    readonly senderId: Schema.optionalKey<Schema.brand<Schema.String, "EmailSenderId">>;
+    readonly templateData: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+}>;
+export type ExtensionVersionRef = {
+    readonly id: ExtensionVersionId;
+    readonly version: string;
+};
+export declare const ExtensionVersionRef: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ExtensionVersionId">;
+    readonly version: Schema.String;
+}>;
+export type UpgradeExtensionPayload = {
+    readonly version?: string | ExtensionVersionId | null;
+    readonly acceptPermissions?: ReadonlyArray<"permission:read" | "permission:update" | "permission:send" | "permission:quarantine.read" | "event:mailbox.message.received" | "event:mailbox.message.sent" | "event:mailbox.action.pending_approval" | "event:mailbox.message.quarantined" | "event:mailbox.message.released" | "event:mailbox.message.discarded"> | null;
+    readonly dryRun?: boolean | null;
+};
+export declare const UpgradeExtensionPayload: Schema.Struct<{
+    readonly version: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.brand<Schema.String, "ExtensionVersionId">]>, Schema.Null]>>;
+    readonly acceptPermissions: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Union<readonly [Schema.Literal<"permission:read">, Schema.Literal<"permission:update">, Schema.Literal<"permission:send">, Schema.Literal<"permission:quarantine.read">, Schema.Literal<"event:mailbox.message.received">, Schema.Literal<"event:mailbox.message.sent">, Schema.Literal<"event:mailbox.action.pending_approval">, Schema.Literal<"event:mailbox.message.quarantined">, Schema.Literal<"event:mailbox.message.released">, Schema.Literal<"event:mailbox.message.discarded">]>>, Schema.Null]>>;
+    readonly dryRun: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+}>;
+export type SendFeedback = {
+    readonly message: string;
+    readonly category?: "bug" | "confusing" | "missing" | "other" | null;
+    readonly context?: FeedbackContext | null;
+};
+export declare const SendFeedback: Schema.Struct<{
+    readonly message: Schema.String;
+    readonly category: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"bug">, Schema.Literal<"confusing">, Schema.Literal<"missing">, Schema.Literal<"other">]>, Schema.Null]>>;
+    readonly context: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly operation: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly resourceId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>, Schema.Null]>>;
+}>;
+export type UpdateJourneyPayload = {
+    readonly name: JourneyName;
+};
+export declare const UpdateJourneyPayload: Schema.Struct<{
+    readonly name: Schema.String;
+}>;
+export type JourneyCustomEventTrigger = {
+    readonly type: "event";
+    readonly eventName: JourneyCustomEventName;
+};
+export declare const JourneyCustomEventTrigger: Schema.Struct<{
+    readonly type: Schema.Literal<"event">;
+    readonly eventName: Schema.String;
+}>;
+export type JourneyEventName = JourneyCustomEventName | "contact.created" | "contact.tag_added" | "contact.joined_group";
+export declare const JourneyEventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+export type JourneyNextEdge = {
+    readonly nodeId: JourneyNodeId;
+};
+export declare const JourneyNextEdge: Schema.Struct<{
+    readonly nodeId: Schema.String;
+}>;
+export type JourneyWaitEventEdge = {
+    readonly nodeId: JourneyNodeId;
+    readonly outcome: "matched" | "timed_out";
+};
+export declare const JourneyWaitEventEdge: Schema.Struct<{
+    readonly nodeId: Schema.String;
+    readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+}>;
+export type JourneyExitNode = {
+    readonly type: "exit";
+    readonly config: JourneyEmptyConfig;
+    readonly next: readonly [];
+};
+export declare const JourneyExitNode: Schema.Struct<{
+    readonly type: Schema.Literal<"exit">;
+    readonly config: Schema.$Record<Schema.String, Schema.Never>;
+    readonly next: Schema.Tuple<readonly []>;
+}>;
+export type JourneyComparison = JourneyEqualityComparison | JourneyNumericComparison | JourneyStringComparison | JourneyPresenceComparison;
+export declare const JourneyComparison: Schema.Union<readonly [Schema.Struct<{
+    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+}>, Schema.Struct<{
+    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+    readonly value: Schema.Finite;
+}>, Schema.Struct<{
+    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+    readonly value: Schema.String;
+}>, Schema.Struct<{
+    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+}>]>;
+export type CreateMailboxEndpointPayload = {
+    readonly channel: MailboxChannel;
+    readonly address: string;
+    readonly displayName?: string | null;
+};
+export declare const CreateMailboxEndpointPayload: Schema.Struct<{
+    readonly channel: Schema.Literal<"email">;
+    readonly address: Schema.String;
+    readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type UpdateMailboxPayload = {
+    readonly name?: string | null;
+    readonly metadata?: MailboxMetadataPatch | null;
+};
+export declare const UpdateMailboxPayload: Schema.Struct<{
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly metadata: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Null]>>, Schema.Null]>>;
+}>;
+export type MailboxActionDecision = {
+    readonly outcome: "allow" | "requireApproval" | "deny";
+    readonly reason: string | null;
+    readonly policyId: MailboxPolicyId | null;
+    readonly source: "grant" | "installation" | "policy" | null;
+    readonly decidedAt: string;
+};
+export declare const MailboxActionDecision: Schema.Struct<{
+    readonly outcome: Schema.Union<readonly [Schema.Literal<"allow">, Schema.Literal<"requireApproval">, Schema.Literal<"deny">]>;
+    readonly reason: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly policyId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxPolicyId">, Schema.Null]>;
+    readonly source: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"grant">, Schema.Literal<"installation">, Schema.Literal<"policy">]>, Schema.Null]>;
+    readonly decidedAt: Schema.String;
+}>;
+export type MailboxSendOutcome = {
+    readonly code: string;
+    readonly message: string;
+    readonly error?: MailboxSendError | null;
+};
+export declare const MailboxSendOutcome: Schema.Struct<{
+    readonly code: Schema.String;
+    readonly message: Schema.String;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"SenderNotReadyError">;
+        readonly message: Schema.String;
+        readonly sender: Schema.String;
+        readonly retryAfterSeconds: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Null]>>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"RateLimitedError">;
+        readonly message: Schema.String;
+        readonly retryAfterSeconds: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"OnboardingReviewRequiredError">;
+        readonly message: Schema.String;
+        readonly code: Schema.Union<readonly [Schema.Literal<"review_required">, Schema.Literal<"review_in_progress">, Schema.Literal<"information_required">, Schema.Literal<"review_rejected">, Schema.Literal<"identity_review_required">, Schema.Literal<"identity_review_rejected">, Schema.Literal<"identity_changed">]>;
+        readonly decision: Schema.Union<readonly [Schema.Literal<"undecided">, Schema.Literal<"approved">, Schema.Literal<"rejected">]>;
+        readonly stage: Schema.Union<readonly [Schema.Literal<"collecting">, Schema.Literal<"automated_review">, Schema.Literal<"manual_review">, Schema.Literal<"information_requested">, Schema.Literal<"complete">]>;
+        readonly nextAction: Schema.Union<readonly [Schema.Literal<"wait_for_review">, Schema.Literal<"provide_information">, Schema.Literal<"verify_sending_identity">, Schema.Literal<"reapply">, Schema.Literal<"contact_support">]>;
+        readonly identityId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"PaymentRequiredError">;
+        readonly message: Schema.String;
+        readonly resource: Schema.String;
+        readonly currentUsage: Schema.Finite;
+        readonly limit: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"ValidationError">;
+        readonly message: Schema.String;
+        readonly fields: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Null]>>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"ForbiddenError">;
+        readonly message: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"ResourceNotFoundError">;
+        readonly resource: Schema.String;
+        readonly id: Schema.String;
+        readonly message: Schema.String;
+    }>]>, Schema.Null]>>;
+}>;
+export type CreateMailboxGrantPayload = {
+    readonly userId: UserId;
+    readonly role: MailboxGrantRole;
+    readonly sendMode?: MailboxSendMode | null;
+};
+export declare const CreateMailboxGrantPayload: Schema.Struct<{
+    readonly userId: Schema.brand<Schema.String, "UserId">;
+    readonly role: Schema.Union<readonly [Schema.Literal<"admin">, Schema.Literal<"collaborator">, Schema.Literal<"viewer">]>;
+    readonly sendMode: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"send">, Schema.Literal<"approval">]>, Schema.Null]>>;
+}>;
+export type UpdateMailboxGrantPayload = {
+    readonly role?: MailboxGrantRole | null;
+    readonly sendMode?: MailboxSendMode | null;
+};
+export declare const UpdateMailboxGrantPayload: Schema.Struct<{
+    readonly role: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"admin">, Schema.Literal<"collaborator">, Schema.Literal<"viewer">]>, Schema.Null]>>;
+    readonly sendMode: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"send">, Schema.Literal<"approval">]>, Schema.Null]>>;
+}>;
+export type MailboxThreadLabels = {
+    readonly labels: readonly [MailboxLabelId, ...Array<MailboxLabelId>];
+};
+export declare const MailboxThreadLabels: Schema.Struct<{
+    readonly labels: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.brand<Schema.String, "MailboxLabelId">]>, readonly [Schema.brand<Schema.String, "MailboxLabelId">]>;
+}>;
+export type CreateMailboxPolicyPayload = {
+    readonly name: string;
+    readonly outcome: MailboxPolicyOutcomeKind;
+    readonly reason?: string | null;
+    readonly enabled?: boolean | null;
+};
+export declare const CreateMailboxPolicyPayload: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly outcome: Schema.Union<readonly [Schema.Literal<"requireApproval">, Schema.Literal<"deny">]>;
+    readonly reason: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly enabled: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+}>;
+export type UpdateMailboxPolicyPayload = {
+    readonly name?: string | null;
+    readonly outcome?: MailboxPolicyOutcomeKind | null;
+    readonly reason?: string | null | null;
+    readonly enabled?: boolean | null;
+};
+export declare const UpdateMailboxPolicyPayload: Schema.Struct<{
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly outcome: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"requireApproval">, Schema.Literal<"deny">]>, Schema.Null]>>;
+    readonly reason: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    readonly enabled: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+}>;
+export type UpdateMailboxThreadPayload = {
+    readonly folder?: MailboxThreadFolder | null;
+    readonly priority?: MailboxThreadPriority | null;
+    readonly read?: boolean | null;
+    readonly starred?: boolean | null;
+    readonly snoozedUntil?: string | null | null;
+};
+export declare const UpdateMailboxThreadPayload: Schema.Struct<{
+    readonly folder: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"inbox">, Schema.Literal<"assigned">, Schema.Literal<"pending">, Schema.Literal<"sent">, Schema.Literal<"archived">, Schema.Literal<"trash">]>, Schema.Null]>>;
+    readonly priority: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"low">, Schema.Literal<"normal">, Schema.Literal<"high">, Schema.Literal<"urgent">]>, Schema.Null]>>;
+    readonly read: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+    readonly starred: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+    readonly snoozedUntil: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+}>;
+export type CreateNamespacePayload = {
+    readonly name: string;
+    readonly metadata?: NamespaceMetadata | null;
+};
+export declare const CreateNamespacePayload: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly metadata: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.String>, Schema.Null]>>;
+}>;
+export type Operation = {
+    readonly id: OperationId;
+    readonly organizationId: string;
+    readonly kind: "email-domain-provisioning" | "organization-deletion";
+    readonly subject: OperationResource;
+    readonly actor: {
+        readonly type: "user" | "api-key" | "system";
+        readonly id: string;
+    };
+    readonly status: "pending" | "running" | "succeeded" | "failed";
+    readonly phase: "accepted" | "dispatching" | "provisioning" | "deleting" | "finalizing" | "completed";
+    readonly error: {
+        readonly code: "validation-failed" | "conflict" | "capacity-unavailable" | "rejected" | "unavailable" | "timed-out" | "internal";
+        readonly message: string;
+    } | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly startedAt: string | null;
+    readonly completedAt: string | null;
+};
+export declare const Operation: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "OperationId">;
+    readonly organizationId: Schema.String;
+    readonly kind: Schema.Union<readonly [Schema.Literal<"email-domain-provisioning">, Schema.Literal<"organization-deletion">]>;
+    readonly subject: Schema.Struct<{
+        readonly type: Schema.String;
+        readonly id: Schema.String;
+    }>;
+    readonly actor: Schema.Struct<{
+        readonly type: Schema.Union<readonly [Schema.Literal<"user">, Schema.Literal<"api-key">, Schema.Literal<"system">]>;
+        readonly id: Schema.String;
+    }>;
+    readonly status: Schema.Union<readonly [Schema.Literal<"pending">, Schema.Literal<"running">, Schema.Literal<"succeeded">, Schema.Literal<"failed">]>;
+    readonly phase: Schema.Union<readonly [Schema.Literal<"accepted">, Schema.Literal<"dispatching">, Schema.Literal<"provisioning">, Schema.Literal<"deleting">, Schema.Literal<"finalizing">, Schema.Literal<"completed">]>;
+    readonly error: Schema.Union<readonly [Schema.Struct<{
+        readonly code: Schema.Union<readonly [Schema.Literal<"validation-failed">, Schema.Literal<"conflict">, Schema.Literal<"capacity-unavailable">, Schema.Literal<"rejected">, Schema.Literal<"unavailable">, Schema.Literal<"timed-out">, Schema.Literal<"internal">]>;
+        readonly message: Schema.String;
+    }>, Schema.Null]>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly startedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly completedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+}>;
+export type OperationResourceLink = {
+    readonly resource: OperationResource;
+    readonly href: string;
+};
+export declare const OperationResourceLink: Schema.Struct<{
+    readonly resource: Schema.Struct<{
+        readonly type: Schema.String;
+        readonly id: Schema.String;
+    }>;
+    readonly href: Schema.String;
+}>;
+export type UpdateTemplatePayload = {
+    readonly data: {
+        readonly name?: string | null;
+        readonly slug?: string | null;
+        readonly entryPath?: string | null;
+        readonly description?: string | null | null;
+        readonly category?: "transactional" | "marketing" | "support" | "notification" | "verification" | "reminder" | "alert" | null | null;
+        readonly fromDefault?: TemplateFromDefault | null | null;
+        readonly replyToDefault?: ReadonlyArray<string> | null | null;
+        readonly isActive?: boolean | null;
+    };
+};
+export declare const UpdateTemplatePayload: Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly slug: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly entryPath: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly description: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+        readonly category: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"transactional">, Schema.Literal<"marketing">, Schema.Literal<"support">, Schema.Literal<"notification">, Schema.Literal<"verification">, Schema.Literal<"reminder">, Schema.Literal<"alert">]>, Schema.Null]>, Schema.Null]>>;
+        readonly fromDefault: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+            readonly email: Schema.String;
+            readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        }>, Schema.Null]>, Schema.Null]>>;
+        readonly replyToDefault: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>, Schema.Null]>>;
+        readonly isActive: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+    }>;
+}>;
+export type ApiKeyAccess = {
+    readonly mode: "full";
+} | {
+    readonly mode: "restricted";
+    readonly resources: ApiKeyResourceAccess;
+    readonly mailboxes?: ApiKeyMailboxAccess | null;
+    readonly namespaceId?: NamespaceId | null;
+};
+export declare const ApiKeyAccess: Schema.Union<readonly [Schema.Struct<{
+    readonly mode: Schema.Literal<"full">;
+}>, Schema.Struct<{
+    readonly mode: Schema.Literal<"restricted">;
+    readonly resources: Schema.Struct<{
+        readonly messages: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly email: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly domains: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly phoneNumbers: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly contacts: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly conversations: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly templates: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly webhooks: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly apiKeys: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly organization: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly billing: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+        readonly analytics: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"write">]>, Schema.Null]>>;
+    }>;
+    readonly mailboxes: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly permissions: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"update">, Schema.Literal<"send">, Schema.Literal<"quarantine.read">]>]>, readonly [Schema.Union<readonly [Schema.Literal<"read">, Schema.Literal<"update">, Schema.Literal<"send">, Schema.Literal<"quarantine.read">]>]>;
+        readonly mailboxIds: Schema.optionalKey<Schema.Union<readonly [Schema.TupleWithRest<Schema.Tuple<readonly [Schema.brand<Schema.String, "MailboxId">]>, readonly [Schema.brand<Schema.String, "MailboxId">]>, Schema.Null]>>;
+        readonly sendMode: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"send">, Schema.Literal<"approval">]>, Schema.Null]>>;
+    }>, Schema.Null]>>;
+    readonly namespaceId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "NamespaceId">, Schema.Null]>>;
+}>]>;
+export type MessagePage = {
+    readonly items: ReadonlyArray<MessageSummary>;
+    readonly nextCursor: string | null;
+};
+export declare const MessagePage: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "MessageId">;
+        readonly channel: Schema.Literal<"email">;
+        readonly direction: Schema.Union<readonly [Schema.Literal<"outbound">, Schema.Literal<"inbound">]>;
+        readonly status: Schema.Union<readonly [Schema.Literal<"pending">, Schema.Literal<"scheduled">, Schema.Literal<"queued">, Schema.Literal<"processing">, Schema.Literal<"sent">, Schema.Literal<"delivered">, Schema.Literal<"read">, Schema.Literal<"failed">, Schema.Literal<"bounced">, Schema.Literal<"complained">]>;
+        readonly from: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly to: Schema.$Array<Schema.String>;
+        readonly subject: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly waitReason: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"rate">, Schema.Literal<"daily-quota">, Schema.Literal<"domain-health">, Schema.Literal<"sending-paused">, Schema.Literal<"upstream-unavailable">, Schema.Literal<"retry">, Schema.Literal<"campaign-paused">, Schema.Literal<"domain-warming">, Schema.Literal<"onboarding-review">, Schema.Literal<"content-review">, Schema.Literal<"screening-unavailable">]>, Schema.Null]>;
+        readonly createdAt: Schema.String;
+    }>>;
+    readonly nextCursor: Schema.Union<readonly [Schema.String, Schema.Null]>;
+}>;
+export type CreateBrand = {
+    readonly slug: string;
+    readonly name: string;
+    readonly css?: string | null;
+    readonly assets?: BrandAssets | null;
+    readonly footer?: BrandFooter | null;
+    readonly isDefault?: boolean | null;
+};
+export declare const CreateBrand: Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly css: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly assets: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly logoUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly logoDarkUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly iconUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>, Schema.Null]>>;
+    readonly footer: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly companyName: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly address: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly street1: Schema.String;
+            readonly street2: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+            readonly city: Schema.String;
+            readonly region: Schema.String;
+            readonly postalCode: Schema.String;
+            readonly country: Schema.String;
+        }>, Schema.Null]>>;
+        readonly socialLinks: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly url: Schema.String;
+        }>>, Schema.Null]>>;
+    }>, Schema.Null]>>;
+    readonly isDefault: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+}>;
+export type UpdateBrand = {
+    readonly newSlug?: string | null;
+    readonly name?: string | null;
+    readonly css?: string | null;
+    readonly assets?: BrandAssets | null;
+    readonly footer?: BrandFooter | null;
+};
+export declare const UpdateBrand: Schema.Struct<{
+    readonly newSlug: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly css: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly assets: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly logoUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly logoDarkUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly iconUrl: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>, Schema.Null]>>;
+    readonly footer: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly companyName: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly address: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly street1: Schema.String;
+            readonly street2: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+            readonly city: Schema.String;
+            readonly region: Schema.String;
+            readonly postalCode: Schema.String;
+            readonly country: Schema.String;
+        }>, Schema.Null]>>;
+        readonly socialLinks: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly url: Schema.String;
+        }>>, Schema.Null]>>;
+    }>, Schema.Null]>>;
+}>;
+export type EmailAttachments = ReadonlyArray<EmailAttachment> | null;
+export declare const EmailAttachments: Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+    readonly filename: Schema.String;
+    readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+    readonly contentType: Schema.String;
+    readonly size: Schema.Finite;
+}>>, Schema.Null]>;
+export type CreateMailboxDraftPayload = {
+    readonly channel?: "email" | null;
+    readonly endpointId?: MailboxEndpointId | null;
+    readonly to?: ReadonlyArray<string> | null;
+    readonly cc?: ReadonlyArray<string> | null;
+    readonly bcc?: ReadonlyArray<string> | null;
+    readonly replyTo?: ReadonlyArray<string> | null;
+    readonly subject?: string | null;
+    readonly text?: string | null;
+    readonly html?: string | null;
+    readonly attachments?: ReadonlyArray<EmailAttachment> | null;
+    readonly inReplyToMessageId?: MessageId | null;
+};
+export declare const CreateMailboxDraftPayload: Schema.Struct<{
+    readonly channel: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"email">, Schema.Null]>>;
+    readonly endpointId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MailboxEndpointId">, Schema.Null]>>;
+    readonly to: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly cc: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly bcc: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly replyTo: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly subject: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly text: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly html: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly attachments: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+        readonly filename: Schema.String;
+        readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+        readonly contentType: Schema.String;
+        readonly size: Schema.Finite;
+    }>>, Schema.Null]>>;
+    readonly inReplyToMessageId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MessageId">, Schema.Null]>>;
+}>;
+export type ForwardMailboxMessagePayload = {
+    readonly to: readonly [string, ...Array<string>];
+    readonly cc?: ReadonlyArray<string> | null;
+    readonly bcc?: ReadonlyArray<string> | null;
+    readonly text?: string | null;
+    readonly html?: string | null;
+    readonly attachments?: ReadonlyArray<EmailAttachment> | null;
+};
+export declare const ForwardMailboxMessagePayload: Schema.Struct<{
+    readonly to: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.String]>, readonly [Schema.String]>;
+    readonly cc: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly bcc: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly text: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly html: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly attachments: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+        readonly filename: Schema.String;
+        readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+        readonly contentType: Schema.String;
+        readonly size: Schema.Finite;
+    }>>, Schema.Null]>>;
+}>;
+export type ReplyMailboxMessagePayload = {
+    readonly channel?: "email" | null;
+    readonly cc?: ReadonlyArray<string> | null;
+    readonly bcc?: ReadonlyArray<string> | null;
+    readonly text?: string | null;
+    readonly html?: string | null;
+    readonly attachments?: ReadonlyArray<EmailAttachment> | null;
+};
+export declare const ReplyMailboxMessagePayload: Schema.Struct<{
+    readonly channel: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"email">, Schema.Null]>>;
+    readonly cc: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly bcc: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly text: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly html: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly attachments: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+        readonly filename: Schema.String;
+        readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+        readonly contentType: Schema.String;
+        readonly size: Schema.Finite;
+    }>>, Schema.Null]>>;
+}>;
+export type SendMailboxMessagePayload = {
+    readonly channel?: "email" | null;
+    readonly to: readonly [string, ...Array<string>];
+    readonly cc?: ReadonlyArray<string> | null;
+    readonly bcc?: ReadonlyArray<string> | null;
+    readonly replyTo?: ReadonlyArray<string> | null;
+    readonly subject: string;
+    readonly text?: string | null;
+    readonly html?: string | null;
+    readonly attachments?: ReadonlyArray<EmailAttachment> | null;
+};
+export declare const SendMailboxMessagePayload: Schema.Struct<{
+    readonly channel: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"email">, Schema.Null]>>;
+    readonly to: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.String]>, readonly [Schema.String]>;
+    readonly cc: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly bcc: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly replyTo: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly subject: Schema.String;
+    readonly text: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly html: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly attachments: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+        readonly filename: Schema.String;
+        readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+        readonly contentType: Schema.String;
+        readonly size: Schema.Finite;
+    }>>, Schema.Null]>>;
+}>;
+export type UpdateMailboxDraftPayload = {
+    readonly to?: ReadonlyArray<string> | null;
+    readonly cc?: ReadonlyArray<string> | null | null;
+    readonly bcc?: ReadonlyArray<string> | null | null;
+    readonly replyTo?: ReadonlyArray<string> | null | null;
+    readonly subject?: string | null | null;
+    readonly text?: string | null | null;
+    readonly html?: string | null | null;
+    readonly attachments?: ReadonlyArray<EmailAttachment> | null | null;
+};
+export declare const UpdateMailboxDraftPayload: Schema.Struct<{
+    readonly to: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>>;
+    readonly cc: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>, Schema.Null]>>;
+    readonly bcc: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>, Schema.Null]>>;
+    readonly replyTo: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>, Schema.Null]>>;
+    readonly subject: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    readonly text: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    readonly html: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    readonly attachments: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+        readonly filename: Schema.String;
+        readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+        readonly contentType: Schema.String;
+        readonly size: Schema.Finite;
+    }>>, Schema.Null]>, Schema.Null]>>;
+}>;
+export type CreateEventPayload = {
+    readonly contact: ContactEventReference;
+    readonly name: string;
+    readonly properties?: JsonObject | null;
+    readonly occurredAt?: string | null;
+    readonly idempotencyKey?: string | null;
+};
+export declare const CreateEventPayload: Schema.Struct<{
+    readonly contact: Schema.Union<readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ContactId">;
+        readonly externalId: Schema.optionalKey<Schema.Never>;
+        readonly email: Schema.optionalKey<Schema.Never>;
+    }>, Schema.Struct<{
+        readonly externalId: Schema.String;
+        readonly id: Schema.optionalKey<Schema.Never>;
+        readonly email: Schema.optionalKey<Schema.Never>;
+    }>, Schema.Struct<{
+        readonly email: Schema.String;
+        readonly id: Schema.optionalKey<Schema.Never>;
+        readonly externalId: Schema.optionalKey<Schema.Never>;
+    }>]>;
+    readonly name: Schema.String;
+    readonly properties: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>>;
+    readonly occurredAt: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly idempotencyKey: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+}>;
+export type EmailRecipients = ReadonlyArray<EmailRecipient>;
+export declare const EmailRecipients: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly contactId: Schema.brand<Schema.String, "ContactId">;
+}>, Schema.Struct<{
+    readonly email: Schema.String;
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+}>]>>;
+export type EmailCcRecipients = ReadonlyArray<EmailRecipient> | null | null;
+export declare const EmailCcRecipients: Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly contactId: Schema.brand<Schema.String, "ContactId">;
+}>, Schema.Struct<{
+    readonly email: Schema.String;
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+}>]>>, Schema.Null]>, Schema.Null]>;
+export type EmailBccRecipients = ReadonlyArray<EmailRecipient> | null | null;
+export declare const EmailBccRecipients: Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly contactId: Schema.brand<Schema.String, "ContactId">;
+}>, Schema.Struct<{
+    readonly email: Schema.String;
+    readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+}>]>>, Schema.Null]>, Schema.Null]>;
+export type JourneyTrigger = JourneyCustomEventTrigger | JourneyContactCreatedTrigger | JourneyTagAddedTrigger | JourneyGroupJoinedTrigger;
+export declare const JourneyTrigger: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"event">;
+    readonly eventName: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"contact.created">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"contact.tag_added">;
+    readonly tag: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"contact.joined_group">;
+    readonly groupId: Schema.brand<Schema.String, "ContactGroupId">;
+}>]>;
+export type JourneyWaitForEventConfig = {
+    readonly eventName: JourneyEventName;
+    readonly timeoutSeconds: number;
+};
+export declare const JourneyWaitForEventConfig: Schema.Struct<{
+    readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+    readonly timeoutSeconds: Schema.Finite;
+}>;
+export type JourneyEventPredicate = {
+    readonly type: "event";
+    readonly eventName: JourneyEventName;
+    readonly occurred: boolean;
+};
+export declare const JourneyEventPredicate: Schema.Struct<{
+    readonly type: Schema.Literal<"event">;
+    readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+    readonly occurred: Schema.Boolean;
+}>;
+export type JourneyGoal = {
+    readonly eventName: JourneyEventName;
+};
+export declare const JourneyGoal: Schema.Struct<{
+    readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+}>;
+export type JourneySendEmailNode = {
+    readonly type: "send_email";
+    readonly config: JourneySendEmailConfig;
+    readonly next: readonly [JourneyNextEdge];
+};
+export declare const JourneySendEmailNode: Schema.Struct<{
+    readonly type: Schema.Literal<"send_email">;
+    readonly config: Schema.Struct<{
+        readonly template: Schema.Union<readonly [Schema.brand<Schema.String, "TemplateId">, Schema.String]>;
+        readonly senderId: Schema.optionalKey<Schema.brand<Schema.String, "EmailSenderId">>;
+        readonly templateData: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+    }>]>;
+}>;
+export type JourneyWaitNode = {
+    readonly type: "wait";
+    readonly config: JourneyWaitConfig;
+    readonly next: readonly [JourneyNextEdge];
+};
+export declare const JourneyWaitNode: Schema.Struct<{
+    readonly type: Schema.Literal<"wait">;
+    readonly config: Schema.Struct<{
+        readonly durationSeconds: Schema.Finite;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+    }>]>;
+}>;
+export type JourneyUpdateTagsNode = {
+    readonly type: "update_tags";
+    readonly config: JourneyUpdateTagsConfig;
+    readonly next: readonly [JourneyNextEdge];
+};
+export declare const JourneyUpdateTagsNode: Schema.Struct<{
+    readonly type: Schema.Literal<"update_tags">;
+    readonly config: Schema.Struct<{
+        readonly add: Schema.$Array<Schema.String>;
+        readonly remove: Schema.$Array<Schema.String>;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+    }>]>;
+}>;
+export type JourneyWebhookNode = {
+    readonly type: "webhook";
+    readonly config: JourneyWebhookConfig;
+    readonly next: readonly [JourneyNextEdge];
+};
+export declare const JourneyWebhookNode: Schema.Struct<{
+    readonly type: Schema.Literal<"webhook">;
+    readonly config: Schema.Struct<{
+        readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+    }>]>;
+}>;
+export type JourneyPropertyPredicate = {
+    readonly type: "property";
+    readonly field: JourneyContactProperty;
+    readonly comparison: JourneyComparison;
+};
+export declare const JourneyPropertyPredicate: Schema.Struct<{
+    readonly type: Schema.Literal<"property">;
+    readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+    readonly comparison: Schema.Union<readonly [Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+        readonly value: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+        readonly value: Schema.String;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+    }>]>;
+}>;
+export type JourneyCustomFieldPredicate = {
+    readonly type: "custom_field";
+    readonly key: string;
+    readonly comparison: JourneyComparison;
+};
+export declare const JourneyCustomFieldPredicate: Schema.Struct<{
+    readonly type: Schema.Literal<"custom_field">;
+    readonly key: Schema.String;
+    readonly comparison: Schema.Union<readonly [Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+        readonly value: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+        readonly value: Schema.String;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+    }>]>;
+}>;
+export type CreateMailboxPayload = {
+    readonly namespaceId?: NamespaceId | null;
+    readonly endpoint: CreateMailboxEndpointPayload;
+    readonly name: string;
+    readonly slug?: string | null;
+    readonly metadata?: MailboxMetadata | null;
+};
+export declare const CreateMailboxPayload: Schema.Struct<{
+    readonly namespaceId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "NamespaceId">, Schema.Null]>>;
+    readonly endpoint: Schema.Struct<{
+        readonly channel: Schema.Literal<"email">;
+        readonly address: Schema.String;
+        readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>;
+    readonly name: Schema.String;
+    readonly slug: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly metadata: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.String>, Schema.Null]>>;
+}>;
+export type MailboxSendReceipt = {
+    readonly actionId: MailboxActionId;
+    readonly draftId: MailboxDraftId | null;
+    readonly messageId: MessageId | null;
+    readonly threadId: MailboxThreadId | null;
+    readonly state: "approvalRequired" | "queued" | "accepted" | "completed" | "notSent" | "uncertain";
+    readonly acceptedAt: string | null;
+    readonly waitReason: "rate" | "daily-quota" | "domain-health" | "sending-paused" | "upstream-unavailable" | "retry" | "campaign-paused" | "domain-warming" | "onboarding-review" | "content-review" | "screening-unavailable" | null;
+    readonly reviewExpectedAt: string | null;
+    readonly skippedRecipients: ReadonlyArray<SkippedRecipient>;
+    readonly executeUntil: string | null;
+    readonly retryAt: string | null;
+    readonly problem: MailboxSendOutcome | null;
+    readonly retryEligible: boolean;
+    readonly decision: MailboxActionDecision | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+};
+export declare const MailboxSendReceipt: Schema.Struct<{
+    readonly actionId: Schema.brand<Schema.String, "MailboxActionId">;
+    readonly draftId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxDraftId">, Schema.Null]>;
+    readonly messageId: Schema.Union<readonly [Schema.brand<Schema.String, "MessageId">, Schema.Null]>;
+    readonly threadId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxThreadId">, Schema.Null]>;
+    readonly state: Schema.Union<readonly [Schema.Literal<"approvalRequired">, Schema.Literal<"queued">, Schema.Literal<"accepted">, Schema.Literal<"completed">, Schema.Literal<"notSent">, Schema.Literal<"uncertain">]>;
+    readonly acceptedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly waitReason: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"rate">, Schema.Literal<"daily-quota">, Schema.Literal<"domain-health">, Schema.Literal<"sending-paused">, Schema.Literal<"upstream-unavailable">, Schema.Literal<"retry">, Schema.Literal<"campaign-paused">, Schema.Literal<"domain-warming">, Schema.Literal<"onboarding-review">, Schema.Literal<"content-review">, Schema.Literal<"screening-unavailable">]>, Schema.Null]>;
+    readonly reviewExpectedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly skippedRecipients: Schema.$Array<Schema.Struct<{
+        readonly address: Schema.String;
+        readonly reason: Schema.Union<readonly [Schema.Literal<"bounce">, Schema.Literal<"complaint">, Schema.Literal<"unsubscribe">, Schema.Literal<"manual">, Schema.Literal<"group-unsubscribe">]>;
+        readonly unsubscribeGroupId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "UnsubscribeId">, Schema.Null]>>;
+    }>>;
+    readonly executeUntil: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly retryAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly problem: Schema.Union<readonly [Schema.Struct<{
+        readonly code: Schema.String;
+        readonly message: Schema.String;
+        readonly error: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.Literal<"SenderNotReadyError">;
+            readonly message: Schema.String;
+            readonly sender: Schema.String;
+            readonly retryAfterSeconds: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Null]>>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.Literal<"RateLimitedError">;
+            readonly message: Schema.String;
+            readonly retryAfterSeconds: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.Literal<"OnboardingReviewRequiredError">;
+            readonly message: Schema.String;
+            readonly code: Schema.Union<readonly [Schema.Literal<"review_required">, Schema.Literal<"review_in_progress">, Schema.Literal<"information_required">, Schema.Literal<"review_rejected">, Schema.Literal<"identity_review_required">, Schema.Literal<"identity_review_rejected">, Schema.Literal<"identity_changed">]>;
+            readonly decision: Schema.Union<readonly [Schema.Literal<"undecided">, Schema.Literal<"approved">, Schema.Literal<"rejected">]>;
+            readonly stage: Schema.Union<readonly [Schema.Literal<"collecting">, Schema.Literal<"automated_review">, Schema.Literal<"manual_review">, Schema.Literal<"information_requested">, Schema.Literal<"complete">]>;
+            readonly nextAction: Schema.Union<readonly [Schema.Literal<"wait_for_review">, Schema.Literal<"provide_information">, Schema.Literal<"verify_sending_identity">, Schema.Literal<"reapply">, Schema.Literal<"contact_support">]>;
+            readonly identityId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.Literal<"PaymentRequiredError">;
+            readonly message: Schema.String;
+            readonly resource: Schema.String;
+            readonly currentUsage: Schema.Finite;
+            readonly limit: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.Literal<"ValidationError">;
+            readonly message: Schema.String;
+            readonly fields: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Null]>>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.Literal<"ForbiddenError">;
+            readonly message: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.Literal<"ResourceNotFoundError">;
+            readonly resource: Schema.String;
+            readonly id: Schema.String;
+            readonly message: Schema.String;
+        }>]>, Schema.Null]>>;
+    }>, Schema.Null]>;
+    readonly retryEligible: Schema.Boolean;
+    readonly decision: Schema.Union<readonly [Schema.Struct<{
+        readonly outcome: Schema.Union<readonly [Schema.Literal<"allow">, Schema.Literal<"requireApproval">, Schema.Literal<"deny">]>;
+        readonly reason: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly policyId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxPolicyId">, Schema.Null]>;
+        readonly source: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"grant">, Schema.Literal<"installation">, Schema.Literal<"policy">]>, Schema.Null]>;
+        readonly decidedAt: Schema.String;
+    }>, Schema.Null]>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export type OperationAccepted = {
+    readonly operation: Operation;
+    readonly links: {
+        readonly self: string;
+        readonly resource: OperationResourceLink;
+    };
+};
+export declare const OperationAccepted: Schema.Struct<{
+    readonly operation: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "OperationId">;
+        readonly organizationId: Schema.String;
+        readonly kind: Schema.Union<readonly [Schema.Literal<"email-domain-provisioning">, Schema.Literal<"organization-deletion">]>;
+        readonly subject: Schema.Struct<{
+            readonly type: Schema.String;
+            readonly id: Schema.String;
+        }>;
+        readonly actor: Schema.Struct<{
+            readonly type: Schema.Union<readonly [Schema.Literal<"user">, Schema.Literal<"api-key">, Schema.Literal<"system">]>;
+            readonly id: Schema.String;
+        }>;
+        readonly status: Schema.Union<readonly [Schema.Literal<"pending">, Schema.Literal<"running">, Schema.Literal<"succeeded">, Schema.Literal<"failed">]>;
+        readonly phase: Schema.Union<readonly [Schema.Literal<"accepted">, Schema.Literal<"dispatching">, Schema.Literal<"provisioning">, Schema.Literal<"deleting">, Schema.Literal<"finalizing">, Schema.Literal<"completed">]>;
+        readonly error: Schema.Union<readonly [Schema.Struct<{
+            readonly code: Schema.Union<readonly [Schema.Literal<"validation-failed">, Schema.Literal<"conflict">, Schema.Literal<"capacity-unavailable">, Schema.Literal<"rejected">, Schema.Literal<"unavailable">, Schema.Literal<"timed-out">, Schema.Literal<"internal">]>;
+            readonly message: Schema.String;
+        }>, Schema.Null]>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+        readonly startedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly completedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    }>;
+    readonly links: Schema.Struct<{
+        readonly self: Schema.String;
+        readonly resource: Schema.Struct<{
+            readonly resource: Schema.Struct<{
+                readonly type: Schema.String;
+                readonly id: Schema.String;
+            }>;
+            readonly href: Schema.String;
+        }>;
+    }>;
+}>;
+export type EmailContent = {
+    readonly subject?: string | null;
+    readonly html?: string | null;
+    readonly text?: string | null;
+    readonly attachments?: EmailAttachments;
+    readonly publicationId?: TemplatePublicationId;
+    readonly inputContractId?: TemplateInputContractId;
+    readonly templateId?: TemplateId | null;
+    readonly templateSlug?: string | null;
+    readonly templateData?: TemplateData;
+    readonly locale?: RenderLocale;
+    readonly timeZone?: RenderTimeZone;
+    readonly inReplyToMessageId?: MessageId | null;
+    readonly replyTo?: ReplyToAddresses;
+    readonly unsubscribeGroupId?: UnsubscribeId | null | null;
+    readonly tracking?: EmailTrackingOverrideV1;
+    readonly footer?: EmailFooterOverride;
+};
+export declare const EmailContent: Schema.Struct<{
+    readonly subject: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly html: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly text: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly attachments: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+        readonly filename: Schema.String;
+        readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+        readonly contentType: Schema.String;
+        readonly size: Schema.Finite;
+    }>>, Schema.Null]>>;
+    readonly publicationId: Schema.optionalKey<Schema.brand<Schema.String, "TemplatePublicationId">>;
+    readonly inputContractId: Schema.optionalKey<Schema.brand<Schema.String, "TemplateInputContractId">>;
+    readonly templateId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "TemplateId">, Schema.Null]>>;
+    readonly templateSlug: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly templateData: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>>;
+    readonly locale: Schema.optionalKey<Schema.String>;
+    readonly timeZone: Schema.optionalKey<Schema.String>;
+    readonly inReplyToMessageId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MessageId">, Schema.Null]>>;
+    readonly replyTo: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>, Schema.Null]>>;
+    readonly unsubscribeGroupId: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.String, "UnsubscribeId">, Schema.Null]>, Schema.Null]>>;
+    readonly tracking: Schema.optionalKey<Schema.Struct<{
+        readonly opens: Schema.optionalKey<Schema.Boolean>;
+        readonly clicks: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    readonly footer: Schema.optionalKey<Schema.Struct<{
+        readonly enabled: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+    }>>;
+}>;
+export type EmailDispatchContent = {
+    readonly subject?: string | null;
+    readonly html?: string | null;
+    readonly text?: string | null;
+    readonly attachments?: EmailAttachments;
+    readonly publicationId?: TemplatePublicationId;
+    readonly inputContractId?: TemplateInputContractId;
+    readonly templateId?: TemplateId | null;
+    readonly templateSlug?: string | null;
+    readonly templateData?: TemplateData;
+    readonly locale?: RenderLocale;
+    readonly timeZone?: RenderTimeZone;
+    readonly inReplyToMessageId?: MessageId | null;
+    readonly replyTo?: ReplyToAddresses;
+    readonly unsubscribeGroupId?: UnsubscribeId | null | null;
+    readonly tracking?: EmailTrackingOverrideV1;
+    readonly footer?: EmailFooterOverride;
+};
+export declare const EmailDispatchContent: Schema.Struct<{
+    readonly subject: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly html: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly text: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly attachments: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+        readonly filename: Schema.String;
+        readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+        readonly contentType: Schema.String;
+        readonly size: Schema.Finite;
+    }>>, Schema.Null]>>;
+    readonly publicationId: Schema.optionalKey<Schema.brand<Schema.String, "TemplatePublicationId">>;
+    readonly inputContractId: Schema.optionalKey<Schema.brand<Schema.String, "TemplateInputContractId">>;
+    readonly templateId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "TemplateId">, Schema.Null]>>;
+    readonly templateSlug: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly templateData: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>>;
+    readonly locale: Schema.optionalKey<Schema.String>;
+    readonly timeZone: Schema.optionalKey<Schema.String>;
+    readonly inReplyToMessageId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MessageId">, Schema.Null]>>;
+    readonly replyTo: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>, Schema.Null]>>;
+    readonly unsubscribeGroupId: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.String, "UnsubscribeId">, Schema.Null]>, Schema.Null]>>;
+    readonly tracking: Schema.optionalKey<Schema.Struct<{
+        readonly opens: Schema.optionalKey<Schema.Boolean>;
+        readonly clicks: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    readonly footer: Schema.optionalKey<Schema.Struct<{
+        readonly enabled: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+    }>>;
+}>;
+export type BatchEventsPayload = {
+    readonly events: readonly [CreateEventPayload, ...Array<CreateEventPayload>];
+};
+export declare const BatchEventsPayload: Schema.Struct<{
+    readonly events: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Struct<{
+        readonly contact: Schema.Union<readonly [Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ContactId">;
+            readonly externalId: Schema.optionalKey<Schema.Never>;
+            readonly email: Schema.optionalKey<Schema.Never>;
+        }>, Schema.Struct<{
+            readonly externalId: Schema.String;
+            readonly id: Schema.optionalKey<Schema.Never>;
+            readonly email: Schema.optionalKey<Schema.Never>;
+        }>, Schema.Struct<{
+            readonly email: Schema.String;
+            readonly id: Schema.optionalKey<Schema.Never>;
+            readonly externalId: Schema.optionalKey<Schema.Never>;
+        }>]>;
+        readonly name: Schema.String;
+        readonly properties: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>>;
+        readonly occurredAt: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly idempotencyKey: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>]>, readonly [Schema.Struct<{
+        readonly contact: Schema.Union<readonly [Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ContactId">;
+            readonly externalId: Schema.optionalKey<Schema.Never>;
+            readonly email: Schema.optionalKey<Schema.Never>;
+        }>, Schema.Struct<{
+            readonly externalId: Schema.String;
+            readonly id: Schema.optionalKey<Schema.Never>;
+            readonly email: Schema.optionalKey<Schema.Never>;
+        }>, Schema.Struct<{
+            readonly email: Schema.String;
+            readonly id: Schema.optionalKey<Schema.Never>;
+            readonly externalId: Schema.optionalKey<Schema.Never>;
+        }>]>;
+        readonly name: Schema.String;
+        readonly properties: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>>;
+        readonly occurredAt: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly idempotencyKey: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>]>;
+}>;
+export type JourneyWaitForEventNode = {
+    readonly type: "wait_for_event";
+    readonly config: JourneyWaitForEventConfig;
+    readonly next: readonly [JourneyWaitEventEdge, JourneyWaitEventEdge];
+};
+export declare const JourneyWaitForEventNode: Schema.Struct<{
+    readonly type: Schema.Literal<"wait_for_event">;
+    readonly config: Schema.Struct<{
+        readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+        readonly timeoutSeconds: Schema.Finite;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+    }>, Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+    }>]>;
+}>;
+export type JourneyPredicate = JourneyTagPredicate | JourneyPropertyPredicate | JourneyCustomFieldPredicate | JourneyEventPredicate;
+export declare const JourneyPredicate: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"tag">;
+    readonly tag: Schema.String;
+    readonly present: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"property">;
+    readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+    readonly comparison: Schema.Union<readonly [Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+        readonly value: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+        readonly value: Schema.String;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+    }>]>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"custom_field">;
+    readonly key: Schema.String;
+    readonly comparison: Schema.Union<readonly [Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+        readonly value: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+        readonly value: Schema.String;
+    }>, Schema.Struct<{
+        readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+    }>]>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"event">;
+    readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+    readonly occurred: Schema.Boolean;
+}>]>;
+declare const MailboxSendRefusedError_base: Schema.Class<MailboxSendRefusedError, Schema.Struct<{
+    readonly _tag: Schema.tag<"MailboxSendRefusedError">;
+    readonly message: Schema.String;
+    readonly receipt: Schema.Struct<{
+        readonly actionId: Schema.brand<Schema.String, "MailboxActionId">;
+        readonly draftId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxDraftId">, Schema.Null]>;
+        readonly messageId: Schema.Union<readonly [Schema.brand<Schema.String, "MessageId">, Schema.Null]>;
+        readonly threadId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxThreadId">, Schema.Null]>;
+        readonly state: Schema.Union<readonly [Schema.Literal<"approvalRequired">, Schema.Literal<"queued">, Schema.Literal<"accepted">, Schema.Literal<"completed">, Schema.Literal<"notSent">, Schema.Literal<"uncertain">]>;
+        readonly acceptedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly waitReason: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"rate">, Schema.Literal<"daily-quota">, Schema.Literal<"domain-health">, Schema.Literal<"sending-paused">, Schema.Literal<"upstream-unavailable">, Schema.Literal<"retry">, Schema.Literal<"campaign-paused">, Schema.Literal<"domain-warming">, Schema.Literal<"onboarding-review">, Schema.Literal<"content-review">, Schema.Literal<"screening-unavailable">]>, Schema.Null]>;
+        readonly reviewExpectedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly skippedRecipients: Schema.$Array<Schema.Struct<{
+            readonly address: Schema.String;
+            readonly reason: Schema.Union<readonly [Schema.Literal<"bounce">, Schema.Literal<"complaint">, Schema.Literal<"unsubscribe">, Schema.Literal<"manual">, Schema.Literal<"group-unsubscribe">]>;
+            readonly unsubscribeGroupId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "UnsubscribeId">, Schema.Null]>>;
+        }>>;
+        readonly executeUntil: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly retryAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly problem: Schema.Union<readonly [Schema.Struct<{
+            readonly code: Schema.String;
+            readonly message: Schema.String;
+            readonly error: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+                readonly _tag: Schema.Literal<"SenderNotReadyError">;
+                readonly message: Schema.String;
+                readonly sender: Schema.String;
+                readonly retryAfterSeconds: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Null]>>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"RateLimitedError">;
+                readonly message: Schema.String;
+                readonly retryAfterSeconds: Schema.Finite;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"OnboardingReviewRequiredError">;
+                readonly message: Schema.String;
+                readonly code: Schema.Union<readonly [Schema.Literal<"review_required">, Schema.Literal<"review_in_progress">, Schema.Literal<"information_required">, Schema.Literal<"review_rejected">, Schema.Literal<"identity_review_required">, Schema.Literal<"identity_review_rejected">, Schema.Literal<"identity_changed">]>;
+                readonly decision: Schema.Union<readonly [Schema.Literal<"undecided">, Schema.Literal<"approved">, Schema.Literal<"rejected">]>;
+                readonly stage: Schema.Union<readonly [Schema.Literal<"collecting">, Schema.Literal<"automated_review">, Schema.Literal<"manual_review">, Schema.Literal<"information_requested">, Schema.Literal<"complete">]>;
+                readonly nextAction: Schema.Union<readonly [Schema.Literal<"wait_for_review">, Schema.Literal<"provide_information">, Schema.Literal<"verify_sending_identity">, Schema.Literal<"reapply">, Schema.Literal<"contact_support">]>;
+                readonly identityId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"PaymentRequiredError">;
+                readonly message: Schema.String;
+                readonly resource: Schema.String;
+                readonly currentUsage: Schema.Finite;
+                readonly limit: Schema.Finite;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"ValidationError">;
+                readonly message: Schema.String;
+                readonly fields: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Null]>>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"ForbiddenError">;
+                readonly message: Schema.String;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"ResourceNotFoundError">;
+                readonly resource: Schema.String;
+                readonly id: Schema.String;
+                readonly message: Schema.String;
+            }>]>, Schema.Null]>>;
+        }>, Schema.Null]>;
+        readonly retryEligible: Schema.Boolean;
+        readonly decision: Schema.Union<readonly [Schema.Struct<{
+            readonly outcome: Schema.Union<readonly [Schema.Literal<"allow">, Schema.Literal<"requireApproval">, Schema.Literal<"deny">]>;
+            readonly reason: Schema.Union<readonly [Schema.String, Schema.Null]>;
+            readonly policyId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxPolicyId">, Schema.Null]>;
+            readonly source: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"grant">, Schema.Literal<"installation">, Schema.Literal<"policy">]>, Schema.Null]>;
+            readonly decidedAt: Schema.String;
+        }>, Schema.Null]>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+export declare class MailboxSendRefusedError extends MailboxSendRefusedError_base {
+}
+declare const MailboxSendConflictError_base: Schema.Class<MailboxSendConflictError, Schema.Struct<{
+    readonly _tag: Schema.tag<"MailboxSendConflictError">;
+    readonly message: Schema.String;
+    readonly resource: Schema.String;
+    readonly id: Schema.brand<Schema.String, "MailboxActionId">;
+    readonly receipt: Schema.Struct<{
+        readonly actionId: Schema.brand<Schema.String, "MailboxActionId">;
+        readonly draftId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxDraftId">, Schema.Null]>;
+        readonly messageId: Schema.Union<readonly [Schema.brand<Schema.String, "MessageId">, Schema.Null]>;
+        readonly threadId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxThreadId">, Schema.Null]>;
+        readonly state: Schema.Union<readonly [Schema.Literal<"approvalRequired">, Schema.Literal<"queued">, Schema.Literal<"accepted">, Schema.Literal<"completed">, Schema.Literal<"notSent">, Schema.Literal<"uncertain">]>;
+        readonly acceptedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly waitReason: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"rate">, Schema.Literal<"daily-quota">, Schema.Literal<"domain-health">, Schema.Literal<"sending-paused">, Schema.Literal<"upstream-unavailable">, Schema.Literal<"retry">, Schema.Literal<"campaign-paused">, Schema.Literal<"domain-warming">, Schema.Literal<"onboarding-review">, Schema.Literal<"content-review">, Schema.Literal<"screening-unavailable">]>, Schema.Null]>;
+        readonly reviewExpectedAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly skippedRecipients: Schema.$Array<Schema.Struct<{
+            readonly address: Schema.String;
+            readonly reason: Schema.Union<readonly [Schema.Literal<"bounce">, Schema.Literal<"complaint">, Schema.Literal<"unsubscribe">, Schema.Literal<"manual">, Schema.Literal<"group-unsubscribe">]>;
+            readonly unsubscribeGroupId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "UnsubscribeId">, Schema.Null]>>;
+        }>>;
+        readonly executeUntil: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly retryAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+        readonly problem: Schema.Union<readonly [Schema.Struct<{
+            readonly code: Schema.String;
+            readonly message: Schema.String;
+            readonly error: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+                readonly _tag: Schema.Literal<"SenderNotReadyError">;
+                readonly message: Schema.String;
+                readonly sender: Schema.String;
+                readonly retryAfterSeconds: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Null]>>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"RateLimitedError">;
+                readonly message: Schema.String;
+                readonly retryAfterSeconds: Schema.Finite;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"OnboardingReviewRequiredError">;
+                readonly message: Schema.String;
+                readonly code: Schema.Union<readonly [Schema.Literal<"review_required">, Schema.Literal<"review_in_progress">, Schema.Literal<"information_required">, Schema.Literal<"review_rejected">, Schema.Literal<"identity_review_required">, Schema.Literal<"identity_review_rejected">, Schema.Literal<"identity_changed">]>;
+                readonly decision: Schema.Union<readonly [Schema.Literal<"undecided">, Schema.Literal<"approved">, Schema.Literal<"rejected">]>;
+                readonly stage: Schema.Union<readonly [Schema.Literal<"collecting">, Schema.Literal<"automated_review">, Schema.Literal<"manual_review">, Schema.Literal<"information_requested">, Schema.Literal<"complete">]>;
+                readonly nextAction: Schema.Union<readonly [Schema.Literal<"wait_for_review">, Schema.Literal<"provide_information">, Schema.Literal<"verify_sending_identity">, Schema.Literal<"reapply">, Schema.Literal<"contact_support">]>;
+                readonly identityId: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"PaymentRequiredError">;
+                readonly message: Schema.String;
+                readonly resource: Schema.String;
+                readonly currentUsage: Schema.Finite;
+                readonly limit: Schema.Finite;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"ValidationError">;
+                readonly message: Schema.String;
+                readonly fields: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.$Array<Schema.String>>, Schema.Null]>>;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"ForbiddenError">;
+                readonly message: Schema.String;
+            }>, Schema.Struct<{
+                readonly _tag: Schema.Literal<"ResourceNotFoundError">;
+                readonly resource: Schema.String;
+                readonly id: Schema.String;
+                readonly message: Schema.String;
+            }>]>, Schema.Null]>>;
+        }>, Schema.Null]>;
+        readonly retryEligible: Schema.Boolean;
+        readonly decision: Schema.Union<readonly [Schema.Struct<{
+            readonly outcome: Schema.Union<readonly [Schema.Literal<"allow">, Schema.Literal<"requireApproval">, Schema.Literal<"deny">]>;
+            readonly reason: Schema.Union<readonly [Schema.String, Schema.Null]>;
+            readonly policyId: Schema.Union<readonly [Schema.brand<Schema.String, "MailboxPolicyId">, Schema.Null]>;
+            readonly source: Schema.Union<readonly [Schema.Union<readonly [Schema.Literal<"grant">, Schema.Literal<"installation">, Schema.Literal<"policy">]>, Schema.Null]>;
+            readonly decidedAt: Schema.String;
+        }>, Schema.Null]>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+export declare class MailboxSendConflictError extends MailboxSendConflictError_base {
+}
+export type EmailSendMessagePayload = {
+    readonly conversationId?: ConversationId | null | null;
+    readonly metadata?: MessageMetadata;
+    readonly channel: "email";
+    readonly to: EmailRecipients;
+    readonly cc?: EmailCcRecipients;
+    readonly bcc?: EmailBccRecipients;
+    readonly from?: EmailSender;
+    readonly email: EmailContent;
+};
+export declare const EmailSendMessagePayload: Schema.Struct<{
+    readonly conversationId: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.String, "ConversationId">, Schema.Null]>, Schema.Null]>>;
+    readonly metadata: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>>;
+    readonly channel: Schema.Literal<"email">;
+    readonly to: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly contactId: Schema.brand<Schema.String, "ContactId">;
+    }>, Schema.Struct<{
+        readonly email: Schema.String;
+        readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    }>]>>;
+    readonly cc: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly contactId: Schema.brand<Schema.String, "ContactId">;
+    }>, Schema.Struct<{
+        readonly email: Schema.String;
+        readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    }>]>>, Schema.Null]>, Schema.Null]>>;
+    readonly bcc: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly contactId: Schema.brand<Schema.String, "ContactId">;
+    }>, Schema.Struct<{
+        readonly email: Schema.String;
+        readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly displayName: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Null]>, Schema.Null]>>;
+    }>]>>, Schema.Null]>, Schema.Null]>>;
+    readonly from: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly email: Schema.String;
+        readonly name: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    }>, Schema.Null]>>;
+    readonly email: Schema.Struct<{
+        readonly subject: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly html: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly text: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly attachments: Schema.optionalKey<Schema.Union<readonly [Schema.$Array<Schema.Struct<{
+            readonly filename: Schema.String;
+            readonly content: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+            readonly mediaId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MediaId">, Schema.Null]>>;
+            readonly contentType: Schema.String;
+            readonly size: Schema.Finite;
+        }>>, Schema.Null]>>;
+        readonly publicationId: Schema.optionalKey<Schema.brand<Schema.String, "TemplatePublicationId">>;
+        readonly inputContractId: Schema.optionalKey<Schema.brand<Schema.String, "TemplateInputContractId">>;
+        readonly templateId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "TemplateId">, Schema.Null]>>;
+        readonly templateSlug: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+        readonly templateData: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>, Schema.Null]>>;
+        readonly locale: Schema.optionalKey<Schema.String>;
+        readonly timeZone: Schema.optionalKey<Schema.String>;
+        readonly inReplyToMessageId: Schema.optionalKey<Schema.Union<readonly [Schema.brand<Schema.String, "MessageId">, Schema.Null]>>;
+        readonly replyTo: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.$Array<Schema.String>, Schema.Null]>, Schema.Null]>>;
+        readonly unsubscribeGroupId: Schema.optionalKey<Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.String, "UnsubscribeId">, Schema.Null]>, Schema.Null]>>;
+        readonly tracking: Schema.optionalKey<Schema.Struct<{
+            readonly opens: Schema.optionalKey<Schema.Boolean>;
+            readonly clicks: Schema.optionalKey<Schema.Boolean>;
+        }>>;
+        readonly footer: Schema.optionalKey<Schema.Struct<{
+            readonly enabled: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Null]>>;
+        }>>;
+    }>;
+}>;
+export type JourneyCondition = {
+    readonly match: "all" | "any";
+    readonly predicates: readonly [JourneyPredicate, ...Array<JourneyPredicate>];
+};
+export declare const JourneyCondition: Schema.Struct<{
+    readonly match: Schema.Union<readonly [Schema.Literal<"all">, Schema.Literal<"any">]>;
+    readonly predicates: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tag">;
+        readonly tag: Schema.String;
+        readonly present: Schema.Boolean;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"property">;
+        readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+            readonly value: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+            readonly value: Schema.String;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"custom_field">;
+        readonly key: Schema.String;
+        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+            readonly value: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+            readonly value: Schema.String;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"event">;
+        readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+        readonly occurred: Schema.Boolean;
+    }>]>]>, readonly [Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tag">;
+        readonly tag: Schema.String;
+        readonly present: Schema.Boolean;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"property">;
+        readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+            readonly value: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+            readonly value: Schema.String;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"custom_field">;
+        readonly key: Schema.String;
+        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+            readonly value: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+            readonly value: Schema.String;
+        }>, Schema.Struct<{
+            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"event">;
+        readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+        readonly occurred: Schema.Boolean;
+    }>]>]>;
+}>;
+export type JourneyBranchEdge = {
+    readonly nodeId: JourneyNodeId;
+    readonly condition?: JourneyCondition;
+};
+export declare const JourneyBranchEdge: Schema.Struct<{
+    readonly nodeId: Schema.String;
+    readonly condition: Schema.optionalKey<Schema.Struct<{
+        readonly match: Schema.Union<readonly [Schema.Literal<"all">, Schema.Literal<"any">]>;
+        readonly predicates: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"tag">;
+            readonly tag: Schema.String;
+            readonly present: Schema.Boolean;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"property">;
+            readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+            readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                readonly value: Schema.Finite;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                readonly value: Schema.String;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"custom_field">;
+            readonly key: Schema.String;
+            readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                readonly value: Schema.Finite;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                readonly value: Schema.String;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"event">;
+            readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+            readonly occurred: Schema.Boolean;
+        }>]>]>, readonly [Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"tag">;
+            readonly tag: Schema.String;
+            readonly present: Schema.Boolean;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"property">;
+            readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+            readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                readonly value: Schema.Finite;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                readonly value: Schema.String;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"custom_field">;
+            readonly key: Schema.String;
+            readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                readonly value: Schema.Finite;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                readonly value: Schema.String;
+            }>, Schema.Struct<{
+                readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"event">;
+            readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+            readonly occurred: Schema.Boolean;
+        }>]>]>;
+    }>>;
+}>;
+export type JourneyBranchNode = {
+    readonly type: "branch";
+    readonly config: JourneyEmptyConfig;
+    readonly next: ReadonlyArray<JourneyBranchEdge>;
+};
+export declare const JourneyBranchNode: Schema.Struct<{
+    readonly type: Schema.Literal<"branch">;
+    readonly config: Schema.$Record<Schema.String, Schema.Never>;
+    readonly next: Schema.$Array<Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly condition: Schema.optionalKey<Schema.Struct<{
+            readonly match: Schema.Union<readonly [Schema.Literal<"all">, Schema.Literal<"any">]>;
+            readonly predicates: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tag">;
+                readonly tag: Schema.String;
+                readonly present: Schema.Boolean;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"property">;
+                readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                    readonly value: Schema.Finite;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                    readonly value: Schema.String;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                }>]>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"custom_field">;
+                readonly key: Schema.String;
+                readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                    readonly value: Schema.Finite;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                    readonly value: Schema.String;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                }>]>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"event">;
+                readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                readonly occurred: Schema.Boolean;
+            }>]>]>, readonly [Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tag">;
+                readonly tag: Schema.String;
+                readonly present: Schema.Boolean;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"property">;
+                readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                    readonly value: Schema.Finite;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                    readonly value: Schema.String;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                }>]>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"custom_field">;
+                readonly key: Schema.String;
+                readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                    readonly value: Schema.Finite;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                    readonly value: Schema.String;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                }>]>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"event">;
+                readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                readonly occurred: Schema.Boolean;
+            }>]>]>;
+        }>>;
+    }>>;
+}>;
+export type JourneyNode = JourneySendEmailNode | JourneyWaitNode | JourneyWaitForEventNode | JourneyBranchNode | JourneyUpdateTagsNode | JourneyWebhookNode | JourneyExitNode;
+export declare const JourneyNode: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"send_email">;
+    readonly config: Schema.Struct<{
+        readonly template: Schema.Union<readonly [Schema.brand<Schema.String, "TemplateId">, Schema.String]>;
+        readonly senderId: Schema.optionalKey<Schema.brand<Schema.String, "EmailSenderId">>;
+        readonly templateData: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+    }>]>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"wait">;
+    readonly config: Schema.Struct<{
+        readonly durationSeconds: Schema.Finite;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+    }>]>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"wait_for_event">;
+    readonly config: Schema.Struct<{
+        readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+        readonly timeoutSeconds: Schema.Finite;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+    }>, Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+    }>]>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"branch">;
+    readonly config: Schema.$Record<Schema.String, Schema.Never>;
+    readonly next: Schema.$Array<Schema.Struct<{
+        readonly nodeId: Schema.String;
+        readonly condition: Schema.optionalKey<Schema.Struct<{
+            readonly match: Schema.Union<readonly [Schema.Literal<"all">, Schema.Literal<"any">]>;
+            readonly predicates: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tag">;
+                readonly tag: Schema.String;
+                readonly present: Schema.Boolean;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"property">;
+                readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                    readonly value: Schema.Finite;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                    readonly value: Schema.String;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                }>]>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"custom_field">;
+                readonly key: Schema.String;
+                readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                    readonly value: Schema.Finite;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                    readonly value: Schema.String;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                }>]>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"event">;
+                readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                readonly occurred: Schema.Boolean;
+            }>]>]>, readonly [Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tag">;
+                readonly tag: Schema.String;
+                readonly present: Schema.Boolean;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"property">;
+                readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                    readonly value: Schema.Finite;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                    readonly value: Schema.String;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                }>]>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"custom_field">;
+                readonly key: Schema.String;
+                readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                    readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                    readonly value: Schema.Finite;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                    readonly value: Schema.String;
+                }>, Schema.Struct<{
+                    readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                }>]>;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"event">;
+                readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                readonly occurred: Schema.Boolean;
+            }>]>]>;
+        }>>;
+    }>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"update_tags">;
+    readonly config: Schema.Struct<{
+        readonly add: Schema.$Array<Schema.String>;
+        readonly remove: Schema.$Array<Schema.String>;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+    }>]>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"webhook">;
+    readonly config: Schema.Struct<{
+        readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+    }>;
+    readonly next: Schema.Tuple<readonly [Schema.Struct<{
+        readonly nodeId: Schema.String;
+    }>]>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"exit">;
+    readonly config: Schema.$Record<Schema.String, Schema.Never>;
+    readonly next: Schema.Tuple<readonly []>;
+}>]>;
+export type JourneyDefinition = {
+    readonly trigger: JourneyTrigger;
+    readonly rootNodeId: JourneyNodeId;
+    readonly nodes: {
+        readonly [x: string]: JourneyNode;
+    };
+    readonly goal?: JourneyGoal;
+    readonly reentry?: boolean;
+};
+export declare const JourneyDefinition: Schema.Struct<{
+    readonly trigger: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"event">;
+        readonly eventName: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"contact.created">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"contact.tag_added">;
+        readonly tag: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"contact.joined_group">;
+        readonly groupId: Schema.brand<Schema.String, "ContactGroupId">;
+    }>]>;
+    readonly rootNodeId: Schema.String;
+    readonly nodes: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"send_email">;
+        readonly config: Schema.Struct<{
+            readonly template: Schema.Union<readonly [Schema.brand<Schema.String, "TemplateId">, Schema.String]>;
+            readonly senderId: Schema.optionalKey<Schema.brand<Schema.String, "EmailSenderId">>;
+            readonly templateData: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+        }>;
+        readonly next: Schema.Tuple<readonly [Schema.Struct<{
+            readonly nodeId: Schema.String;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"wait">;
+        readonly config: Schema.Struct<{
+            readonly durationSeconds: Schema.Finite;
+        }>;
+        readonly next: Schema.Tuple<readonly [Schema.Struct<{
+            readonly nodeId: Schema.String;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"wait_for_event">;
+        readonly config: Schema.Struct<{
+            readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+            readonly timeoutSeconds: Schema.Finite;
+        }>;
+        readonly next: Schema.Tuple<readonly [Schema.Struct<{
+            readonly nodeId: Schema.String;
+            readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+        }>, Schema.Struct<{
+            readonly nodeId: Schema.String;
+            readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"branch">;
+        readonly config: Schema.$Record<Schema.String, Schema.Never>;
+        readonly next: Schema.$Array<Schema.Struct<{
+            readonly nodeId: Schema.String;
+            readonly condition: Schema.optionalKey<Schema.Struct<{
+                readonly match: Schema.Union<readonly [Schema.Literal<"all">, Schema.Literal<"any">]>;
+                readonly predicates: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"tag">;
+                    readonly tag: Schema.String;
+                    readonly present: Schema.Boolean;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"property">;
+                    readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                    readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                        readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                        readonly value: Schema.Finite;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                        readonly value: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                    }>]>;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"custom_field">;
+                    readonly key: Schema.String;
+                    readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                        readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                        readonly value: Schema.Finite;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                        readonly value: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                    }>]>;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"event">;
+                    readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                    readonly occurred: Schema.Boolean;
+                }>]>]>, readonly [Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"tag">;
+                    readonly tag: Schema.String;
+                    readonly present: Schema.Boolean;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"property">;
+                    readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                    readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                        readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                        readonly value: Schema.Finite;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                        readonly value: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                    }>]>;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"custom_field">;
+                    readonly key: Schema.String;
+                    readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                        readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                        readonly value: Schema.Finite;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                        readonly value: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                    }>]>;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"event">;
+                    readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                    readonly occurred: Schema.Boolean;
+                }>]>]>;
+            }>>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"update_tags">;
+        readonly config: Schema.Struct<{
+            readonly add: Schema.$Array<Schema.String>;
+            readonly remove: Schema.$Array<Schema.String>;
+        }>;
+        readonly next: Schema.Tuple<readonly [Schema.Struct<{
+            readonly nodeId: Schema.String;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"webhook">;
+        readonly config: Schema.Struct<{
+            readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+        }>;
+        readonly next: Schema.Tuple<readonly [Schema.Struct<{
+            readonly nodeId: Schema.String;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"exit">;
+        readonly config: Schema.$Record<Schema.String, Schema.Never>;
+        readonly next: Schema.Tuple<readonly []>;
+    }>]>>;
+    readonly goal: Schema.optionalKey<Schema.Struct<{
+        readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+    }>>;
+    readonly reentry: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type CreateJourneyPayload = {
+    readonly name: JourneyName;
+    readonly definition: JourneyDefinition;
+};
+export declare const CreateJourneyPayload: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly definition: Schema.Struct<{
+        readonly trigger: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"event">;
+            readonly eventName: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"contact.created">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"contact.tag_added">;
+            readonly tag: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"contact.joined_group">;
+            readonly groupId: Schema.brand<Schema.String, "ContactGroupId">;
+        }>]>;
+        readonly rootNodeId: Schema.String;
+        readonly nodes: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"send_email">;
+            readonly config: Schema.Struct<{
+                readonly template: Schema.Union<readonly [Schema.brand<Schema.String, "TemplateId">, Schema.String]>;
+                readonly senderId: Schema.optionalKey<Schema.brand<Schema.String, "EmailSenderId">>;
+                readonly templateData: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"wait">;
+            readonly config: Schema.Struct<{
+                readonly durationSeconds: Schema.Finite;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"wait_for_event">;
+            readonly config: Schema.Struct<{
+                readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                readonly timeoutSeconds: Schema.Finite;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+                readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+            }>, Schema.Struct<{
+                readonly nodeId: Schema.String;
+                readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"branch">;
+            readonly config: Schema.$Record<Schema.String, Schema.Never>;
+            readonly next: Schema.$Array<Schema.Struct<{
+                readonly nodeId: Schema.String;
+                readonly condition: Schema.optionalKey<Schema.Struct<{
+                    readonly match: Schema.Union<readonly [Schema.Literal<"all">, Schema.Literal<"any">]>;
+                    readonly predicates: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"tag">;
+                        readonly tag: Schema.String;
+                        readonly present: Schema.Boolean;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"property">;
+                        readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                            readonly value: Schema.Finite;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                            readonly value: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                        }>]>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"custom_field">;
+                        readonly key: Schema.String;
+                        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                            readonly value: Schema.Finite;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                            readonly value: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                        }>]>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"event">;
+                        readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                        readonly occurred: Schema.Boolean;
+                    }>]>]>, readonly [Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"tag">;
+                        readonly tag: Schema.String;
+                        readonly present: Schema.Boolean;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"property">;
+                        readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                            readonly value: Schema.Finite;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                            readonly value: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                        }>]>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"custom_field">;
+                        readonly key: Schema.String;
+                        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                            readonly value: Schema.Finite;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                            readonly value: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                        }>]>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"event">;
+                        readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                        readonly occurred: Schema.Boolean;
+                    }>]>]>;
+                }>>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"update_tags">;
+            readonly config: Schema.Struct<{
+                readonly add: Schema.$Array<Schema.String>;
+                readonly remove: Schema.$Array<Schema.String>;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"webhook">;
+            readonly config: Schema.Struct<{
+                readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"exit">;
+            readonly config: Schema.$Record<Schema.String, Schema.Never>;
+            readonly next: Schema.Tuple<readonly []>;
+        }>]>>;
+        readonly goal: Schema.optionalKey<Schema.Struct<{
+            readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+        }>>;
+        readonly reentry: Schema.optionalKey<Schema.Boolean>;
+    }>;
+}>;
+export type ReplaceJourneyDraftPayload = {
+    readonly revision: string;
+    readonly definition: JourneyDefinition;
+};
+export declare const ReplaceJourneyDraftPayload: Schema.Struct<{
+    readonly revision: Schema.String;
+    readonly definition: Schema.Struct<{
+        readonly trigger: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"event">;
+            readonly eventName: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"contact.created">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"contact.tag_added">;
+            readonly tag: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"contact.joined_group">;
+            readonly groupId: Schema.brand<Schema.String, "ContactGroupId">;
+        }>]>;
+        readonly rootNodeId: Schema.String;
+        readonly nodes: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"send_email">;
+            readonly config: Schema.Struct<{
+                readonly template: Schema.Union<readonly [Schema.brand<Schema.String, "TemplateId">, Schema.String]>;
+                readonly senderId: Schema.optionalKey<Schema.brand<Schema.String, "EmailSenderId">>;
+                readonly templateData: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"wait">;
+            readonly config: Schema.Struct<{
+                readonly durationSeconds: Schema.Finite;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"wait_for_event">;
+            readonly config: Schema.Struct<{
+                readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                readonly timeoutSeconds: Schema.Finite;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+                readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+            }>, Schema.Struct<{
+                readonly nodeId: Schema.String;
+                readonly outcome: Schema.Union<readonly [Schema.Literal<"matched">, Schema.Literal<"timed_out">]>;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"branch">;
+            readonly config: Schema.$Record<Schema.String, Schema.Never>;
+            readonly next: Schema.$Array<Schema.Struct<{
+                readonly nodeId: Schema.String;
+                readonly condition: Schema.optionalKey<Schema.Struct<{
+                    readonly match: Schema.Union<readonly [Schema.Literal<"all">, Schema.Literal<"any">]>;
+                    readonly predicates: Schema.TupleWithRest<Schema.Tuple<readonly [Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"tag">;
+                        readonly tag: Schema.String;
+                        readonly present: Schema.Boolean;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"property">;
+                        readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                            readonly value: Schema.Finite;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                            readonly value: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                        }>]>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"custom_field">;
+                        readonly key: Schema.String;
+                        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                            readonly value: Schema.Finite;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                            readonly value: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                        }>]>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"event">;
+                        readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                        readonly occurred: Schema.Boolean;
+                    }>]>]>, readonly [Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"tag">;
+                        readonly tag: Schema.String;
+                        readonly present: Schema.Boolean;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"property">;
+                        readonly field: Schema.Union<readonly [Schema.Literal<"name">, Schema.Literal<"displayName">, Schema.Literal<"externalId">, Schema.Literal<"status">, Schema.Literal<"profile.firstName">, Schema.Literal<"profile.lastName">, Schema.Literal<"profile.company">, Schema.Literal<"profile.jobTitle">, Schema.Literal<"profile.source">, Schema.Literal<"profile.location.country">, Schema.Literal<"profile.location.state">, Schema.Literal<"profile.location.city">, Schema.Literal<"profile.location.timezone">]>;
+                        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                            readonly value: Schema.Finite;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                            readonly value: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                        }>]>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"custom_field">;
+                        readonly key: Schema.String;
+                        readonly comparison: Schema.Union<readonly [Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"eq">, Schema.Literal<"neq">]>;
+                            readonly value: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"gt">, Schema.Literal<"gte">, Schema.Literal<"lt">, Schema.Literal<"lte">]>;
+                            readonly value: Schema.Finite;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"contains">, Schema.Literal<"not_contains">, Schema.Literal<"starts_with">, Schema.Literal<"ends_with">]>;
+                            readonly value: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly operator: Schema.Union<readonly [Schema.Literal<"exists">, Schema.Literal<"not_exists">]>;
+                        }>]>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"event">;
+                        readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+                        readonly occurred: Schema.Boolean;
+                    }>]>]>;
+                }>>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"update_tags">;
+            readonly config: Schema.Struct<{
+                readonly add: Schema.$Array<Schema.String>;
+                readonly remove: Schema.$Array<Schema.String>;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"webhook">;
+            readonly config: Schema.Struct<{
+                readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<JsonValue, JsonValue, never, never>>>>;
+            }>;
+            readonly next: Schema.Tuple<readonly [Schema.Struct<{
+                readonly nodeId: Schema.String;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"exit">;
+            readonly config: Schema.$Record<Schema.String, Schema.Never>;
+            readonly next: Schema.Tuple<readonly []>;
+        }>]>>;
+        readonly goal: Schema.optionalKey<Schema.Struct<{
+            readonly eventName: Schema.Union<readonly [Schema.String, Schema.Union<readonly [Schema.Literal<"contact.created">, Schema.Literal<"contact.tag_added">, Schema.Literal<"contact.joined_group">]>]>;
+        }>>;
+        readonly reentry: Schema.optionalKey<Schema.Boolean>;
+    }>;
+}>;
+export { __SamvaRuntimeAbsoluteInstant, __SamvaRuntimeSensitiveString };
+export declare const ApiKeySecurity: HttpApiSecurity.ApiKey;
+declare const ApiKeySecurityMiddleware_base: HttpApiMiddleware.ServiceClass<ApiKeySecurityMiddleware, "apiKey security", {
+    requires: never;
+    provides: never;
+    error: never;
+    clientError: never;
+    requiredForClient: false;
+    security: {
+        readonly apiKey: HttpApiSecurity.ApiKey;
+    };
+}, HttpApiMiddleware.HttpApiMiddlewareSecurity<{
+    readonly apiKey: HttpApiSecurity.ApiKey;
+}, never, never, never>>;
+export declare class ApiKeySecurityMiddleware extends ApiKeySecurityMiddleware_base {
+}