Rem drv: <create type="types" />
Rem
Rem $Header: emcore/source/oracle/sysman/emdrep/sql/core/latest/emSDK/notification/sdk_notification_types.sql rbali_oneoff_updated/1 2025/03/14 06:41:14 rbali Exp $
Rem
Rem sdk_notification_types.sql
Rem
Rem Copyright (c) 2011, 2025, Oracle and/or its affiliates. 
Rem All rights reserved.

Rem BEGIN EMRU_FILE_METADATA
Rem EMRU_SOURCE_FILE:emcore/source/oracle/sysman/emdrep/sql/core/latest/emSDK/notification/sdk_notification_types.sql
Rem EMRU_UNIX_DELIVERABLES:
Rem emcore/source/oracle/sysman/emdrep/sql/core/latest/emSDK/notification/sdk_notification_types.sql

Rem EMRU_FILE_POSTINSTALL:<!!! enter the view based location of the executable file. If there is NONE leave as-is !!!>
Rem EMRU_GENERIC_FLAG:NONE
Rem END EMRU_FILE_METADATA

Rem
Rem    NAME
Rem      sdk_notification_types.sql - <one-line expansion of the name>
Rem
Rem    DESCRIPTION
Rem      This file provides the Oracle Database Type definitions for Oracle users who 
Rem      customize Notification based on PL/SQL Procedure.
Rem
Rem    NOTES
Rem      <other useful comments, qualifications, etc.>
Rem
Rem    MODIFIED   (MM/DD/YY)
Rem    gbafna      02/03/25 - 
Rem    gbafna      01/07/25 - make synonyms noneditionable
Rem    jricoir     06/25/15 - Create types under SYSMAN_TYPES schema
Rem    jricoir     05/28/15 - Fix bug#20884323: Add Internal Reported State as
Rem                           anotification payload
Rem    zeding      04/01/13 - add rca related count
Rem    jianpeng    02/28/11 - emSDK notification types definition
Rem    jianpeng    02/28/11 - Created
Rem


Rem
Rem The file contains event, incident and problem related database objects 
Rem that custom PL/SQL programs receive. Custom programs to be invoked
Rem can be configured through incident rules.
Rem 

Rem
Rem Internal note: Translated fields have been set to 4 times the normal length to 
Rem accomdate the extra size due to translation.
Rem

ALTER SESSION SET CURRENT_SCHEMA=SYSMAN_TYPES;

/**
 *  gc$notif_event_attr is used for providing an event type specific attribute information.
 *
 *  name                 - The internal name of event type specific attribute.
 *  value                - The value for attribute.
 *  nls_value            - Translated value for the attribute.
 */
CREATE OR REPLACE TYPE gc$notif_event_attr AS OBJECT (
    name                        VARCHAR2(64),
    value                       VARCHAR2(4000),
    nls_value                   VARCHAR2(4000)
);   -- gc$notif_event_attr
/

grant execute on gc$notif_event_attr to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_event_attr');
END;
/

/**
 * gc$notif_event_attr_array is used for providing event type specific attributes.
 */

CREATE OR REPLACE TYPE gc$notif_event_attr_array AS VARRAY(35) OF gc$notif_event_attr;
/

grant execute on gc$notif_event_attr_array to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_event_attr_array');
END;
/

/**
 * gc$notif_udtp is used for providing a User Defined Target Property (UDTP).
 * 
 * name                 - Name of property.
 * value                - Property value.
 * label                - Property label.
 * nls_id               - Property nsl id.
 */
CREATE OR REPLACE TYPE gc$notif_udtp AS OBJECT (
    name                        VARCHAR2(64),
    value                       VARCHAR2(1024),
    label                       VARCHAR2(256),
    nls_id                      VARCHAR2(64)
); -- gc$notif_udtp
/

grant execute on gc$notif_udtp to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_udtp');
END;
/

/**
 * gc$notif_udtp_array is used for providing User Defined Target Properties.
 */
CREATE OR REPLACE TYPE gc$notif_udtp_array AS VARRAY(20) OF gc$notif_udtp;
/

grant execute on gc$notif_udtp_array to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_udtp_array');
END;
/

/**
 * Target information object is used for providing target information.
 *
 *  target_guid               - Target's global unique identifier. 
 *  target_name               - Name of target.
 *  target_owner              - Owner of target.
 *  target_lifecycle_status   - LifeCycle Status of the target.
 *  target_version            - Target Version of the target.
 *  target_type               - Display type of a target. Based on type_display_name of mgmt_targets.
 *  target_timezone           - Target's regional time zone.
 *  host_name                 - The name of the host on which the target is deployed upon.
 *  target url                - Target's EM Console url.
 *  udtp_array                - The list of user defined target properties.
 *                              It is populated for events that are associated with a target.
 *                              It is populated for incidents and problems, when they are
 *                              associated with a single source (gc$notif_source_info).
 */
CREATE OR REPLACE TYPE gc$notif_target AS OBJECT (
    target_guid                 RAW(16),
    target_name                 VARCHAR2(256),
    target_owner                VARCHAR2(256),
    target_lifecycle_status     VARCHAR2(1024),
    target_version              VARCHAR2(64),
    target_type                 VARCHAR2(128),
    target_timezone             VARCHAR2(64),
    host_name                   VARCHAR2(256),
    target_url                  VARCHAR2(4000),
    udtp_array                  gc$notif_udtp_array
);
/

grant execute on gc$notif_target to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_target');
END;
/

/**
 * gc$notif_source is used for providing information about non target sources, such as JOB.
 *
 * source_guid              - Source's global unique identifier.
 * source_type              - Type of the source object, e.g., JOB, TEMPLATE, etc,. (translated)
 * source_name              - Source Object Name.
 * source_owner             - Owner of the Source object.
 * source_sub_type          - Subtype of the Source object (translated). For example, it provides
 *                            the underlying job type for job status change events.
 * source_url               - Source's event console url.
 */
CREATE OR REPLACE TYPE gc$notif_source AS OBJECT (
    source_guid             RAW(16),
    source_type             VARCHAR2(120),
    source_name             VARCHAR2(256),
    source_owner            VARCHAR2(256),
    source_sub_type         VARCHAR2(256),
    source_url              VARCHAR2(4000)
);
/

grant execute on gc$notif_source to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_source');
END;
/

/**
 * gc$notif_source_info is used for providing information about 
 * associated target and source of an event. Note that an event
 * can be related to a target or a source or both.
 *
 * target                - populated when the event is related to a target.
 * source                - populated when the event is related to a (non-target) source.
 */
CREATE OR REPLACE TYPE gc$notif_source_info AS OBJECT(
    target                      gc$notif_target,
    source                      gc$notif_source
);
/

grant execute on gc$notif_source_info to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_source_info');
END;
/

/**
 * gc$notif_source_info_array is used providing access to the multiple
 * sources that an incident or a problem could be related to.
 * NOTE: The notification system delivers up to 200 sources associated 
 * with an incident or a problem.
 */
CREATE OR REPLACE TYPE gc$notif_source_info_array AS VARRAY(200) OF gc$notif_source_info;
/

grant execute on gc$notif_source_info_array to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_source_info_array');
END;
/

/**
 * gc$notif_corrective_action_job provides information about the execution
 * of a corrective action job. Note that the corrective actions are 
 * supported for metric alert and target availability events only.
 *
 * job_guid              - Corrective Action Job global unique identifier.
 * job_name              - The value will be the name of the Corrective Action. 
 *                         It applies to Metric Alert and Target Availability Events.
 * job_owner             - Corrective Action Job owner.
 * job_type              - Corrective Action Job type (translated).
 * job_status            - Corrective action job execution status.
 * job_status_code       - Corrective action job execution status code.
 *                         It is the internal value defined in EM.
 * job_step_output       - The value will be the text output from the Corrective Action
 *                         execution. This will be truncated to last 4000 characters.
 * job_execution_guid    - Corrective Action Job execution global unique identifier.
 * job_state_change_guid - Corrective Action Job change global unique identifier.
 * occurred_date         - Corrective Action Job occurred date 
 */
CREATE OR REPLACE TYPE gc$notif_corrective_action_job AS OBJECT (
    job_guid                        RAW(16),
    job_name                        VARCHAR2(128),
    job_owner                       VARCHAR2(256),
    job_type                        VARCHAR2(256),
    job_status                      VARCHAR2(64),
    job_status_code                 NUMBER,
    job_step_output                 VARCHAR2(4000),
    job_execution_guid              RAW(16),
    job_state_change_guid           RAW(16),
    occurred_date                   DATE
);
/

grant execute on gc$notif_corrective_action_job to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_corrective_action_job');
END;
/

/** 
  * Each gc$notif_event_context object provides additional context about an event.
  * It consists of the following elements.
  *
  * name                 - The event context name.
  * type                 - The data type of the value, which is stored
  *                          (0) - for numeric data
  *                          (1) - for string data
  * value                - The numerical value.
  * string_value         - The string value.
  */
CREATE OR REPLACE TYPE gc$notif_event_context AS OBJECT (
    name                        VARCHAR2(256),
    type                        NUMBER(1),
    value                       NUMBER,  -- not null for numeric data
    string_value                VARCHAR2(4000)  -- not null for string
); -- gc$notif_event_context
/

grant execute on gc$notif_event_context to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_event_context');
END;
/

/**
 * gc$notif_event_context_array provides information about the additional 
 * diagnostic data that was captured at event detection time. Note that
 * notification system delivers up to 200 elements from the captured
 * event context.
 */
CREATE OR REPLACE TYPE gc$notif_event_context_array AS VARRAY(200) OF gc$notif_event_context;
/

grant execute on gc$notif_event_context_array to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_event_context_array');
END;
/

/**
 * 
 * It is an array of string containing the categories which event, incident or problem 
 * is associated with. Note that notification system delivers up to 10 categories.
 * 
 */
CREATE OR REPLACE TYPE gc$category_string_array AS VARRAY(10) OF VARCHAR2(64);
/

grant execute on gc$category_string_array to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$category_string_array');
END;
/

/**
 * gc$notif_issue_summary is used for providing associated incident summary of 
 * an event payload, or associated problem summary of an incident payload.
 *
 * id                    - Issue Id, either Incident Id or Problem Id.
 * severity              - Issue severity (translated).
 * severity_code         - Issue Severity Code, has one of the following values.
 *                          GC$EVENT.FATAL 
 *                          GC$EVENT.CRITICAL
 *                          GC$EVENT.WARNING 
 *                          GC$EVENT.MINOR_WARNING
 *                          GC$EVENT.INFORMATIONAL 
 *                          GC$EVENT.CLEAR
 * priority               - Issue priority (translated).
 * priority_code          - Issue priority code, has one of the following values.
 *                          GC$EVENT.PRIORITY_URGENT
 *                          GC$EVENT.PRIORITY_VERY_HIGH
 *                          GC$EVENT.PRIORITY_HIGH
 *                          GC$EVENT.PRIORITY_MEDIUM
 *                          GC$EVENT.PRIORITY_LOW
 *                          GC$EVENT.PRIORITY_NONE
 * status                 - Resolution status of the issue, has one of the following values.
 *                          GC$EVENT.STATUS_NEW
 *                          GC$EVENT.RESOLVED
 *                          Any other user defined status.
 * escalation_level       - Escalation level of the issue, has a value between 0 to 5. 
 * owner                  - Issue Owner. Set to NULL if no owner exists.
 * acknowledged_by_owner  - Set to 1, if this issue was acknowledged by owner.
 */
CREATE OR REPLACE TYPE gc$notif_issue_summary AS OBJECT(
    id                      NUMBER,
    severity                VARCHAR2(128),
    severity_code           VARCHAR2(32),
    priority                VARCHAR2(128),
    priority_code           VARCHAR2(32),
    status                  VARCHAR2(64),
    escalation_level        VARCHAR2(2),
    owner                   VARCHAR2(256),
    acknowledged_by_owner   NUMBER(1)
);
/

grant execute on gc$notif_issue_summary to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_issue_summary');
END;
/

/** 
 * gc$notif_event_payload represents the event notification payload.
 * It has the following elemenets.
 *
 * event_instance_guid    - Event instance global unique identifier.
 * event_sequence_guid    - Event sequence global unique identifier.
 *                          Its value remains the same until the event is cleared.
 * target                 - Related target
 * source                 - Related source, that is not a target.
 * event_attrs            - The list of event type specific attributes.
 * corrective_action      - Corrective action information, optionally populated when
 *                          corrective action job execution has completed.
 * event_type             - Event type - Example: Metric Alert
 * event_name             - Event name.
 * event_msg              - Event message.
 * reported_date          - Event reported date.
 * occurrence_date        - Event occurrence_date.
 * severity               - Severity of event (translated).
 * severity_code          - Code for event severity. Possible values are the following.
 *                          GC$EVENT.FATAL 
 *                          GC$EVENT.CRITICAL
 *                          GC$EVENT.WARNING 
 *                          GC$EVENT.MINOR_WARNING
 *                          GC$EVENT.INFORMATIONAL 
 *                          GC$EVENT.CLEAR
 * assoc_incident         - Summary of associated incident.
 *                          It is populated if the event is associated with an incident.
 * action_msg             - Message describing the action to take for resolving the event.
 * rca_detail             - Root cause analysis detail. The size of RAC details output is limited
 *                          to 4000 characters long.
 * event_context_data     - Event context data.
 * categories             - List of categories that the event belongs to.
 *                          Category is translated based on locale defined in
 *                          OMS server. Notification system sends up to 10 categories.
 * category_codes         - Codes for the categories. Notification system sends up to 10
 *                          category codes.
 * total_occurrence_count - Total number of event occurrences de-duplicated from all event instances of this event sequence. 
 *                          It is applicable to de-duplicated events.
 * current_occurrence_count  - Number of event occurrences de-duplicated from current event instance. 
 *                             It is applicable to de-duplicated events.
 * current_first_occur_date  - The timestamp of the first de-duplicated event occurrence in the source system from current
 *                             event instance of this event sequence. It is applicable to de-duplicated events.
 * current_last_occur_date   - The timestamp of the last de-duplicated event occurrence in the source system from current 
 *                             event instance of this event sequence. It is applicable to de-duplicated events.
 * rca_status               - summary about about the current rca status for the incident
 * reported_state           - This is an optional value reporting the latest state of an entity and is only applicable for
 *                            events that are representing a state transition for a given entity. For example, for Target availability
 *                            and Job state change events, this value would be the latest state of the target or job, respectively.
 */
CREATE OR REPLACE TYPE gc$notif_event_payload AS OBJECT (
    event_instance_guid         RAW(16),
    event_sequence_guid         RAW(16),
    target                      gc$notif_target,
    source                      gc$notif_source,
    event_attrs                 gc$notif_event_attr_array,
    corrective_action           gc$notif_corrective_action_job,
    event_type                  VARCHAR2(20),
    event_name                  VARCHAR2(512),
    event_msg                   VARCHAR2(4000),
    reported_date               DATE,
    occurrence_date             DATE, 
    severity                    VARCHAR2(128),
    severity_code               VARCHAR2(32),
    assoc_incident              gc$notif_issue_summary,
    action_msg                  VARCHAR2(4000),
    rca_detail                  VARCHAR2(4000),
    event_context_data          gc$notif_event_context_array,
    categories                  gc$category_string_array,
    category_codes              gc$category_string_array,
    total_occurrence_count      NUMBER,
    current_occurrence_count    NUMBER,
    current_first_occur_date    DATE,
    current_last_occur_date     DATE,
    rca_status                  VARCHAR2(128),
    reported_state              VARCHAR2(256)
); -- gc$notif_event_payload
/

grant execute on gc$notif_event_payload to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_event_payload');
END;
/

/** 
 * gc$notif_issue_attrs provides common details for incident and problem.
 * It contains the details such as id, severity, priority, status,
 * categories, acknowledged by owner, and source information associated with, etc..
 * 
 * id                    - ID of the incident or problem
 * severity              - Issue Severity (translated).
 * severity_code         - Code for Severity. Possible values are the 
 *                         The possible values are defined in descending order of severity:
 *                          GC$EVENT.FATAL 
 *                          GC$EVENT.CRITICAL
 *                          GC$EVENT.WARNING 
 *                          GC$EVENT.MINOR_WARNING
 *                          GC$EVENT.INFORMATIONAL 
 *                          GC$EVENT.CLEAR
 * priority               - Issue Priority (translated)
 * priority_code          - Issue Priority. It is the internal value defined in EM.
 *                         The possible values are defined in descending order of priority:
 *                          GC$EVENT.PRIORITY_URGENT
 *                          GC$EVENT.PRIORITY_VERY_HIGH
 *                          GC$EVENT.PRIORITY_HIGH
 *                          GC$EVENT.PRIORITY_MEDIUM
 *                          GC$EVENT.PRIORITY_LOW
 *                          GC$EVENT.PRIORITY_NONE
 * status                - Resolution status of the issue, has one of the following values.
 *                          GC$EVENT.STATUS_NEW
 *                          GC$EVENT.STATUS_CLOSED
 *                          Any other user defined status
 * escalation_level      - Escalation level of the issue, has a value between 0 to 5. 
 * owner                 - Issue Owner. Set to NULL if no owner exists.
 * acknowledged_by_owner - Set to 1, if this issue was acknowledged by owner.
 * creation_date         - Issue creation date.
 * closed_date           - Issue closed_date, null if not closed.
 * categories            - List of categories that the event belongs to.
 *                         Category is translated based on locale defined in
 *                         OMS server. Notification system sends up to 10 categories.
 * category_codes        - Codes for the categories. Notification system sends up to 10
 *                         category codes.
 * source_info_arr       - Array of source information associated with this issue.
 * last_modified_by      - Last modified by user.
 * last_updated_date     - Last updated date.
 * 
 */
CREATE OR REPLACE TYPE gc$notif_issue_attrs AS OBJECT(
    id                          NUMBER(16), 
    severity                    VARCHAR2(128), 
    severity_code               VARCHAR2(32),
    priority                    VARCHAR2(128),
    priority_code               VARCHAR2(32),
    status                      VARCHAR2(32),
    escalation_level            NUMBER(1),
    owner                       VARCHAR2(256),
    acknowledged_by_owner       NUMBER(1),
    creation_date               DATE,
    closed_date                 DATE,
    categories                  gc$category_string_array,
    category_codes              gc$category_string_array,
    source_info_arr             gc$notif_source_info_array, 
    last_modified_by            VARCHAR2(256),
    last_updated_date           DATE
);
/

grant execute on gc$notif_issue_attrs to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_issue_attrs');
END;
/

/** 
 * gc$notif_incident_payload provides the incident notification payload. 
 * It has the following information.
 * 
 * incident_attrs        - Incident specific attributes.
 * assoc_event_count     - The total number of events associated with this incident.
 * ticket_status         - Status of external ticket, if it exists.
 * ticket_id             - ID of external ticket, if it exists.
 * ticket_url            - URL for external ticket, if it exists.
 * assoc_problem         - Summary of the problem, if it has an associated problem. 
 * sr_id                 - The Service Request (SR) associated with this Incident.
 * sr_url                - The url for SR.
 * assoc_problem_key     - Problem key associated with the ADR incident. Problems are critical errors in an Oracle product. 
 *                         The Problem key is a text string that describes the problem. It includes an error code and 
 *                         in some cases, other error-specific values.
 * adr_incident_id       - Automatic Diagnostic Repository (ADR) Incident ID, a unique numeric identifier for the ADR Incident. 
 *                         An ADR Incident is an occurrence of a Problem.
 * adr_ecid              - Execution Context ID (ECID) associated with the associated ADR incident.  
 *                         An ECID is a globally unique identifier used to tag and track a single call through the Oracle software.
 * adr_impact            - Impact of the ADR Incident
 * rca_status            - summary about about the current rca status for incident
 * rca_details           - details about the current rca results for incident
 */
CREATE OR REPLACE TYPE gc$notif_incident_payload AS OBJECT (
    incident_attrs              gc$notif_issue_attrs,
    assoc_event_count           NUMBER,
    ticket_status               VARCHAR2(64),
    ticket_id                   VARCHAR2(128),
    ticket_url                  VARCHAR2(4000),
    assoc_problem               gc$notif_issue_summary,
    sr_id                       VARCHAR2(64),
    sr_url                      VARCHAR2(4000),
    assoc_problem_key          VARCHAR2(850),
    adr_incident_id            NUMBER(20),
    adr_ecid                   VARCHAR2(64),
    adr_impact                 VARCHAR2(512),
    rca_status                 VARCHAR2(128),
    rca_details                VARCHAR2(4000)
); -- gc$notif_incident_payload
/

grant execute on gc$notif_incident_payload to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_incident_payload');
END;
/

/**
 * gc$notif_problem_payload provides the problem notification payload.
 * It has the following information.
 *
 * problem_attrs         - Problem specific attributes.
 * problem_key           - Problem key if it is generated.
 * assoc_incident_count  - Number of incidents associated with this problem.
 * sr_id                 - Oracle Service Request Id, if it exists.
 * sr_url                - URL for Oracle Service Request, if it exists.
 * bug_id                - Oracle Bug ID, if an associated bug exists.
); -- gc$notif_problem_payload
 */
CREATE OR REPLACE TYPE gc$notif_problem_payload AS OBJECT(
    problem_attrs               gc$notif_issue_attrs,
    problem_key                 VARCHAR2(850),
    assoc_incident_count        NUMBER, 
    sr_id                       VARCHAR2(64),
    sr_url                      VARCHAR2(4000),
    bug_id                      VARCHAR2(64)
); -- gc$notif_problem_payload
/

grant execute on gc$notif_problem_payload to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_problem_payload');
END;
/

CREATE OR REPLACE TYPE gc$notif_update_string_array AS VARRAY(16) OF VARCHAR2(4000);
/

grant execute on gc$notif_update_string_array to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_update_string_array');
END;
/

/**
 * gc$notif_msg_info has generic notification information about
 * the specific notification, such as notification_type, rule set 
 * and rule name, etc..
 * 
 * notification_type     - Code for type of notificiation. Set to one of the following
 *                         values : 
 *                          GC$NOTIFICATION.NOTIF_NORMAL
 *                          GC$NOTIFICATION.NOTIF_RETRY
 *                          GC$NOTIFICATION.NOTIF_REPEAT
 *                          GC$NOTIFICATION.NOTIF_DURATION
 * repeat_count          - How many times the notification has been sent out
 *                         before this notification.
 * ruleset_name          - The name of the rule set that triggered this notification
 * rule_name             - The name of the rule that triggered this notification
 * rule_owner            - The owner of the ruleset that triggered this notification
 * message               - The message of the event, incident, or problem.
 * message_url           - EM console URL for this message
 * user_comment          - The comment entered by user on EM Incident Mananger
 * updates               - The updates associated with the notification.
 */
CREATE OR REPLACE TYPE gc$notif_msg_info AS OBJECT(
    notification_type           VARCHAR2(32),
    repeat_count                NUMBER,
    ruleset_name                VARCHAR2(256),
    rule_name                   VARCHAR2(256),
    rule_owner                  VARCHAR2(256),
    message                     VARCHAR2(4000),
    message_url                 VARCHAR2(4000),
    user_comment                VARCHAR2(4000),
    updates                     gc$notif_update_string_array
);
/

grant execute on gc$notif_msg_info to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_msg_info');
END;
/

/**
 * gc$notif_event_msg is the message delivered to custom PL/SQL
 * programs for event notifications. Custom PL/SQL procedure
 * should have the following signature:
 *         procedure p(msg IN gc$notif_event_msg);
 *
 * When a matching event occurs based on registered incident rules,
 * gc$notif_event_msg will be delivered to the custom program. It
 * has the following members.
 *
 * event_payload         - Event payload
 * msg_info              - Envolope level notification information
 */
CREATE OR REPLACE TYPE gc$notif_event_msg AS OBJECT(
    event_payload               gc$notif_event_payload,
    msg_info                    gc$notif_msg_info
);  -- gc$notif_event_msg
/

grant execute on gc$notif_event_msg to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_event_msg');
END;
/

/**
 * gc$notif_incident_msg is the message delivered to custom PL/SQL
 * programs for incident notifications. Custom PL/SQL procedure
 * should have the following signature:
 *         procedure p(msg IN gc$notif_incident_msg);
 *
 * When a matching incident occurs based on registered incident rules,
 * gc$notif_incident_msg will be delivered to the custom program. It
 * has the following members.
 *
 * incident_payload      - Incident payload
 * msg_info              - Envolope level notification information
 */
CREATE OR REPLACE TYPE gc$notif_incident_msg AS OBJECT(
    incident_payload            gc$notif_incident_payload,
    msg_info                    gc$notif_msg_info 
);  -- gc$notif_incident_msg
/

grant execute on gc$notif_incident_msg to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_incident_msg');
END;
/

/**
 * gc$notif_problem_msg is the message delivered to custom PL/SQL
 * programs for problem notifications. Custom PL/SQL procedure
 * should have the following signature:
 *         procedure p(msg IN gc$notif_problem_msg);
 *
 * When a matching problem occurs based on registered incident rules,
 * gc$notif_problem_msg will be delivered to the custom program. It
 * has the following members.
 *
 * problem_payload       - Problem payload
 * msg_info              - Envolope level notification information
 */
CREATE OR REPLACE TYPE gc$notif_problem_msg AS OBJECT(
    problem_payload             gc$notif_problem_payload,
    msg_info                    gc$notif_msg_info 
);  -- gc$notif_problem_msg
/

grant execute on gc$notif_problem_msg to sysman;

BEGIN
    SYSMAN.CUTOVER_SYNONYM('gc$notif_problem_msg');
END;
/

ALTER SESSION SET CURRENT_SCHEMA=SYSMAN;


