Webhooks Events

{
    event: "feature.created";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            id: string;
            dateCreated: string;
            dateUpdated: string;
            archived: boolean;
            description: string;
            /** The userId of the owner (or raw owner name/email for legacy records) */
            owner: string;
            project: string;
            valueType: "boolean" | "string" | "number" | "json";
            defaultValue: string;
            tags: string[];
            environments: Record<string, any>;
            /** Feature IDs. Each feature must evaluate to `true` */
            prerequisites?: string[] | undefined;
            revision: {
                version: number;
                comment: string;
                date: string;
                createdBy: string;
                publishedBy: string;
            };
            customFields?: Record<string, {}> | undefined;
            holdout?: ({
                /** Holdout ID */
                id: string;
                /** The feature value assigned to users in the holdout treatment group */
                value: string;
            } | null) | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.updated";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            id: string;
            dateCreated: string;
            dateUpdated: string;
            archived: boolean;
            description: string;
            /** The userId of the owner (or raw owner name/email for legacy records) */
            owner: string;
            project: string;
            valueType: "boolean" | "string" | "number" | "json";
            defaultValue: string;
            tags: string[];
            environments: Record<string, any>;
            /** Feature IDs. Each feature must evaluate to `true` */
            prerequisites?: string[] | undefined;
            revision: {
                version: number;
                comment: string;
                date: string;
                createdBy: string;
                publishedBy: string;
            };
            customFields?: Record<string, {}> | undefined;
            holdout?: ({
                /** Holdout ID */
                id: string;
                /** The feature value assigned to users in the holdout treatment group */
                value: string;
            } | null) | undefined;
        };
        previous_attributes: {
            id?: string | undefined;
            dateCreated?: string | undefined;
            dateUpdated?: string | undefined;
            archived?: boolean | undefined;
            description?: string | undefined;
            /** The userId of the owner (or raw owner name/email for legacy records) */
            owner?: string | undefined;
            project?: string | undefined;
            valueType?: ("boolean" | "string" | "number" | "json") | undefined;
            defaultValue?: string | undefined;
            tags?: string[] | undefined;
            environments?: Record<string, any> | undefined;
            /** Feature IDs. Each feature must evaluate to `true` */
            prerequisites?: string[] | undefined;
            revision?: {
                version: number;
                comment: string;
                date: string;
                createdBy: string;
                publishedBy: string;
            } | undefined;
            customFields?: Record<string, {}> | undefined;
            holdout?: ({
                /** Holdout ID */
                id: string;
                /** The feature value assigned to users in the holdout treatment group */
                value: string;
            } | null) | undefined;
        };
        changes?: {
            added: Record<string, unknown>;
            removed: Record<string, unknown>;
            modified: Record<string, unknown>;
        } | undefined;
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.deleted";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            id: string;
            dateCreated: string;
            dateUpdated: string;
            archived: boolean;
            description: string;
            /** The userId of the owner (or raw owner name/email for legacy records) */
            owner: string;
            project: string;
            valueType: "boolean" | "string" | "number" | "json";
            defaultValue: string;
            tags: string[];
            environments: Record<string, any>;
            /** Feature IDs. Each feature must evaluate to `true` */
            prerequisites?: string[] | undefined;
            revision: {
                version: number;
                comment: string;
                date: string;
                createdBy: string;
                publishedBy: string;
            };
            customFields?: Record<string, {}> | undefined;
            holdout?: ({
                /** Holdout ID */
                id: string;
                /** The feature value assigned to users in the holdout treatment group */
                value: string;
            } | null) | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.saferollout.ship";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            featureId: string;
            safeRolloutId: string;
            environment: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.saferollout.rollback";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            featureId: string;
            safeRolloutId: string;
            environment: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.saferollout.unhealthy";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            featureId: string;
            safeRolloutId: string;
            environment: string;
            unhealthyReason: ("srm" | "multipleExposures")[];
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.created";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
            entityType: string;
            entityId: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.deleted";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.actions.started";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
            currentStepIndex: number;
            status: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.actions.completed";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
            currentStepIndex: number;
            status: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.actions.rolledBack";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
            currentStepIndex: number;
            status: string;
            targetStepIndex: number;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.actions.jumped";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
            currentStepIndex: number;
            status: string;
            targetStepIndex: number;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.actions.step.advanced";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
            currentStepIndex: number;
            status: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.actions.step.approvalRequired";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
            currentStepIndex: number;
            status: string;
            approvalNotes?: (string | null) | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.actions.awaitingStartApproval";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
            currentStepIndex: number;
            status: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.rampSchedule.actions.startApproved";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            rampScheduleId: string;
            rampName: string;
            orgId: string;
            currentStepIndex: number;
            status: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.created";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.updated";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
            change: "rule.add" | "rule.update" | "rule.delete" | "rule.reorder" | "rule.rampSchedule.set" | "rule.rampSchedule.remove" | "toggle" | "defaultValue" | "prerequisites" | "holdout" | "archive" | "metadata";
            environments?: string[] | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.reviewRequested";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
            reviewComment: string | null;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.approved";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
            reviewer: {
                id?: string | undefined;
                name?: string | undefined;
                email?: string | undefined;
            };
            reviewComment: string | null;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.changesRequested";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
            reviewer: {
                id?: string | undefined;
                name?: string | undefined;
                email?: string | undefined;
            };
            reviewComment: string | null;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.commented";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
            reviewer: {
                id?: string | undefined;
                name?: string | undefined;
                email?: string | undefined;
            };
            reviewComment: string;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.discarded";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.reopened";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.rebased";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.published";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "feature.revision.reverted";
    object: "feature";
    api_version: string;
    created: number;
    data: {
        object: {
            /** The feature this revision belongs to */
            featureId: string;
            baseVersion: number;
            version: number;
            comment: string;
            date: string;
            status: string;
            createdBy?: string | undefined;
            publishedBy?: string | undefined;
            /** The default value at the time this revision was created */
            defaultValue?: string | undefined;
            rules: Record<string, any[]>;
            definitions?: Record<string, string> | undefined;
            environmentsEnabled?: Record<string, boolean> | undefined;
            envPrerequisites?: Record<string, {
                /** Feature ID */
                id: string;
                condition: string;
            }[]> | undefined;
            prerequisites?: {
                /** Feature ID */
                id: string;
                condition: string;
            }[] | undefined;
            metadata?: {} | undefined;
            revertedToVersion: number;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}

{
    event: "experiment.created";
    object: "experiment";
    api_version: string;
    created: number;
    data: {
        object: {
            id: string;
            trackingKey: string;
            dateCreated: string;
            dateUpdated: string;
            name: string;
            type: "standard" | "multi-armed-bandit" | "holdout";
            project: string;
            hypothesis: string;
            description: string;
            tags: string[];
            /** The userId of the owner (or raw owner name/email for legacy records) */
            owner: string;
            ownerEmail?: string | undefined;
            archived: boolean;
            status: string;
            autoRefresh: boolean;
            hashAttribute: string;
            fallbackAttribute?: string | undefined;
            hashVersion: 1 | 2;
            disableStickyBucketing?: boolean | undefined;
            bucketVersion?: number | undefined;
            minBucketVersion?: number | undefined;
            variations: {
                variationId: string;
                key: string;
                name: string;
                description: string;
                screenshots: string[];
            }[];
            phases: {
                name: string;
                dateStarted: string;
                dateEnded: string;
                reasonForStopping: string;
                seed: string;
                coverage: number;
                trafficSplit: {
                    variationId: string;
                    weight: number;
                }[];
                namespace?: {
                    namespaceId: string;
                    enabled?: boolean | undefined;
                    range?: number[] | undefined;
                    ranges?: [
                        number,
                        number
                    ][] | undefined;
                } | undefined;
                targetingCondition: string;
                prerequisites?: {
                    id: string;
                    condition: string;
                }[] | undefined;
                savedGroupTargeting?: {
                    matchType: "all" | "any" | "none";
                    savedGroups: string[];
                }[] | undefined;
            }[];
            settings: {
                datasourceId: string;
                assignmentQueryId: string;
                experimentId: string;
                segmentId: string;
                queryFilter: string;
                inProgressConversions: "include" | "exclude";
                /** Setting attribution model to `"experimentDuration"` is the same as selecting "Ignore Conversion Windows" for the Conversion Window Override. Setting it to `"lookbackOverride"` requires a `lookbackOverride` object to be provided. */
                attributionModel: "firstExposure" | "experimentDuration" | "lookbackOverride";
                /** Controls the lookback override for the experiment. For type "window", value must be a non-negative number and valueUnit is required. */
                lookbackOverride?: {
                    type: "date" | "window";
                    /** For "window" type - non-negative numeric value (e.g. 7 for 7 days). For "date" type a date string. */
                    value: number | string;
                    /** Used when type is "window". Defaults to "days". */
                    valueUnit?: ("minutes" | "hours" | "days" | "weeks") | undefined;
                } | undefined;
                statsEngine: "bayesian" | "frequentist";
                regressionAdjustmentEnabled?: boolean | undefined;
                sequentialTestingEnabled?: boolean | undefined;
                sequentialTestingTuningParameter?: number | undefined;
                /** When null, the organization default is used. */
                postStratificationEnabled?: (boolean | null) | undefined;
                /** Controls the decision framework and metric overrides for the experiment. Replaces the entire stored object on update (does not patch individual fields). */
                decisionFrameworkSettings?: {
                    decisionCriteriaId?: string | undefined;
                    decisionFrameworkMetricOverrides?: {
                        /** ID of the metric to override settings for. */
                        id: string;
                        /** The target relative MDE to use for the metric, expressed as proportions (e.g. use 0.1 for 10%). Must be greater than 0. */
                        targetMDE?: number | undefined;
                    }[] | undefined;
                } | undefined;
                /** Per-metric analysis overrides; also reflected in goals/secondaryMetrics/guardrails overrides when applicable. On create/update, this replaces the entire stored array (it does not patch individual entries). */
                metricOverrides?: {
                    /** ID of the metric to override settings for. */
                    id: string;
                    windowType?: ("conversion" | "lookback" | "") | undefined;
                    windowHours?: number | undefined;
                    delayHours?: number | undefined;
                    /** Must be true for the override to take effect. If true, the other proper prior settings in this object will be used if present. */
                    properPriorOverride?: boolean | undefined;
                    properPriorEnabled?: boolean | undefined;
                    properPriorMean?: number | undefined;
                    properPriorStdDev?: number | undefined;
                    /** Must be true for the override to take effect. If true, the other regression adjustment settings in this object will be used if present. */
                    regressionAdjustmentOverride?: boolean | undefined;
                    regressionAdjustmentEnabled?: boolean | undefined;
                    regressionAdjustmentDays?: number | undefined;
                }[] | undefined;
                goals: {
                    metricId: string;
                    overrides: {
                        delayHours?: number | undefined;
                        windowHours?: number | undefined;
                        window?: ("conversion" | "lookback" | "") | undefined;
                        winRiskThreshold?: number | undefined;
                        loseRiskThreshold?: number | undefined;
                        properPriorOverride?: boolean | undefined;
                        properPriorEnabled?: boolean | undefined;
                        properPriorMean?: number | undefined;
                        properPriorStdDev?: number | undefined;
                        regressionAdjustmentOverride?: boolean | undefined;
                        regressionAdjustmentEnabled?: boolean | undefined;
                        regressionAdjustmentDays?: number | undefined;
                    };
                }[];
                secondaryMetrics: {
                    metricId: string;
                    overrides: {
                        delayHours?: number | undefined;
                        windowHours?: number | undefined;
                        window?: ("conversion" | "lookback" | "") | undefined;
                        winRiskThreshold?: number | undefined;
                        loseRiskThreshold?: number | undefined;
                        properPriorOverride?: boolean | undefined;
                        properPriorEnabled?: boolean | undefined;
                        properPriorMean?: number | undefined;
                        properPriorStdDev?: number | undefined;
                        regressionAdjustmentOverride?: boolean | undefined;
                        regressionAdjustmentEnabled?: boolean | undefined;
                        regressionAdjustmentDays?: number | undefined;
                    };
                }[];
                guardrails: {
                    metricId: string;
                    overrides: {
                        delayHours?: number | undefined;
                        windowHours?: number | undefined;
                        window?: ("conversion" | "lookback" | "") | undefined;
                        winRiskThreshold?: number | undefined;
                        loseRiskThreshold?: number | undefined;
                        properPriorOverride?: boolean | undefined;
                        properPriorEnabled?: boolean | undefined;
                        properPriorMean?: number | undefined;
                        properPriorStdDev?: number | undefined;
                        regressionAdjustmentOverride?: boolean | undefined;
                        regressionAdjustmentEnabled?: boolean | undefined;
                        regressionAdjustmentDays?: number | undefined;
                    };
                }[];
                activationMetric?: {
                    metricId: string;
                    overrides: {
                        delayHours?: number | undefined;
                        windowHours?: number | undefined;
                        window?: ("conversion" | "lookback" | "") | undefined;
                        winRiskThreshold?: number | undefined;
                        loseRiskThreshold?: number | undefined;
                        properPriorOverride?: boolean | undefined;
                        properPriorEnabled?: boolean | undefined;
                        properPriorMean?: number | undefined;
                        properPriorStdDev?: number | undefined;
                        regressionAdjustmentOverride?: boolean | undefined;
                        regressionAdjustmentEnabled?: boolean | undefined;
                        regressionAdjustmentDays?: number | undefined;
                    };
                } | undefined;
            };
            resultSummary?: {
                status: string;
                winner: string;
                conclusions: string;
                releasedVariationId: string;
                excludeFromPayload: boolean;
            } | undefined;
            shareLevel?: ("public" | "organization") | undefined;
            publicUrl?: string | undefined;
            banditScheduleValue?: number | undefined;
            banditScheduleUnit?: ("days" | "hours") | undefined;
            banditBurnInValue?: number | undefined;
            banditBurnInUnit?: ("days" | "hours") | undefined;
            banditConversionWindowValue?: number | undefined;
            banditConversionWindowUnit?: ("days" | "hours") | undefined;
            linkedFeatures?: string[] | undefined;
            hasVisualChangesets?: boolean | undefined;
            hasURLRedirects?: boolean | undefined;
            customFields?: Record<string, any> | undefined;
            /** Custom slices that apply to ALL applicable metrics in the experiment */
            customMetricSlices?: {
                slices: {
                    column: string;
                    levels: string[];
                }[];
            }[] | undefined;
            precomputedUnitDimensionIds?: string[] | undefined;
            /** ID of the default dashboard for this experiment. */
            defaultDashboardId?: string | undefined;
            templateId?: string | undefined;
            statusUpdateSchedule?: ({
                startAt?: string | undefined;
                stopAt?: string | undefined;
                /** Relative end offset. Deferred: resolved to a concrete `stopAt` at the experiment's actual start (or off `dateStarted` when already running). */
                stopAfter?: {
                    value: number;
                    unit: "hours" | "days";
                } | undefined;
                /** What happens at the scheduled end date. `notify` keeps the experiment running and just notifies (soft). `auto-ship` (requires the Decision Framework) ships the winning variation and stops; multi-winner ties break on `tiebreakerMetricId` (higher lift); with no clear winner, `fallback` either keeps running (`notify`) or ships `fallbackVariationId`. `force-ship` stops and rolls out `fallbackVariationId`. `stop` is a hard deadline that stops with no rollout. For `force-ship` and `stop`, the Decision Framework verdict (won/lost/inconclusive) is recorded as metadata when available. */
                scheduledStopPlan?: {
                    mode: "notify" | "auto-ship" | "force-ship" | "stop";
                    tiebreakerMetricId?: string | undefined;
                    fallback: "notify" | "force-ship";
                    fallbackVariationId?: string | undefined;
                } | undefined;
            } | null) | undefined;
            nextScheduledStatusUpdate?: ({
                type: "start" | "stop";
                date: string;
            } | null) | undefined;
        };
    };
    user: {
        type: "dashboard";
        id: string;
        email: string;
        name: string;
    } | {
        type: "api_key";
        apiKey: string;
        id?: string | undefined;
        name?: string | undefined;
        email?: string | undefined;
    } | {
        type: "system";
        subtype?: string | undefined;
        id?: string | undefined;
    } | null;
    tags: string[];
    /** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
    environments: string[];
    containsSecrets: boolean;
}