@burdenoff/microfe-bigconsole 2026.1004.7 → 2026.1005.1

package/dist/generated/wspace-operations.d.ts

@@ -2185,6 +2185,29 @@ export type AlertThrottleFieldsFragment = {
     windowMinutes: number;
     maxAlertsPerWindow: number;
 };
+export type BigConsoleAlertRuleFieldsFragment = {
+    __typename?: 'DataSinkAlert';
+    id: string;
+    name: string;
+    condition: string;
+    conditionType: Types.DataSinkAlertConditionType;
+    severity: Types.AlertSeverity;
+    channels: Array<string>;
+    recipients: Array<string>;
+    enabled: boolean;
+    throttle?: {
+        __typename?: 'AlertThrottle';
+        enabled: boolean;
+        windowMinutes: number;
+        maxAlertsPerWindow: number;
+    } | null;
+    deliveries: Array<{
+        __typename?: 'DataSinkAlertDelivery';
+        channel: Types.DataSinkAlertChannel;
+        channelId: string;
+        recipient: string;
+    }>;
+};
 export type DataSinkAlertFieldsFragment = {
     __typename?: 'DataSinkAlert';
     id: string;
@@ -2544,6 +2567,84 @@ export type BatchDeleteDataSinksMutation = {
         deletedAt?: string | null;
     }>;
 };
+export type BigConsoleUpsertDataSinkAlertMutationVariables = Types.Exact<{
+    dataSinkId: Types.Scalars['ID']['input'];
+    alert: Types.DataSinkAlertInput;
+    expectedVersion: Types.Scalars['Int']['input'];
+}>;
+export type BigConsoleUpsertDataSinkAlertMutation = {
+    __typename?: 'Mutation';
+    upsertDataSinkAlert: {
+        __typename?: 'DataSink';
+        id: string;
+        workspaceId: string;
+        name?: string | null;
+        key: string;
+        version: number;
+        alerts?: Array<{
+            __typename?: 'DataSinkAlert';
+            id: string;
+            name: string;
+            condition: string;
+            conditionType: Types.DataSinkAlertConditionType;
+            severity: Types.AlertSeverity;
+            channels: Array<string>;
+            recipients: Array<string>;
+            enabled: boolean;
+            throttle?: {
+                __typename?: 'AlertThrottle';
+                enabled: boolean;
+                windowMinutes: number;
+                maxAlertsPerWindow: number;
+            } | null;
+            deliveries: Array<{
+                __typename?: 'DataSinkAlertDelivery';
+                channel: Types.DataSinkAlertChannel;
+                channelId: string;
+                recipient: string;
+            }>;
+        }> | null;
+    };
+};
+export type BigConsoleDeleteDataSinkAlertMutationVariables = Types.Exact<{
+    dataSinkId: Types.Scalars['ID']['input'];
+    alertId: Types.Scalars['ID']['input'];
+    expectedVersion: Types.Scalars['Int']['input'];
+}>;
+export type BigConsoleDeleteDataSinkAlertMutation = {
+    __typename?: 'Mutation';
+    deleteDataSinkAlert: {
+        __typename?: 'DataSink';
+        id: string;
+        workspaceId: string;
+        name?: string | null;
+        key: string;
+        version: number;
+        alerts?: Array<{
+            __typename?: 'DataSinkAlert';
+            id: string;
+            name: string;
+            condition: string;
+            conditionType: Types.DataSinkAlertConditionType;
+            severity: Types.AlertSeverity;
+            channels: Array<string>;
+            recipients: Array<string>;
+            enabled: boolean;
+            throttle?: {
+                __typename?: 'AlertThrottle';
+                enabled: boolean;
+                windowMinutes: number;
+                maxAlertsPerWindow: number;
+            } | null;
+            deliveries: Array<{
+                __typename?: 'DataSinkAlertDelivery';
+                channel: Types.DataSinkAlertChannel;
+                channelId: string;
+                recipient: string;
+            }>;
+        }> | null;
+    };
+};
 export type CreateDataSinkMutationVariables = Types.Exact<{
     input: Types.CreateDataSinkInput;
 }>;
@@ -2890,6 +2991,105 @@ export type UpdateDataSinkMutation = {
         } | null;
     };
 };
+export type BigConsoleDataSinkAlertsQueryVariables = Types.Exact<{
+    dataSinkId: Types.Scalars['ID']['input'];
+}>;
+export type BigConsoleDataSinkAlertsQuery = {
+    __typename?: 'Query';
+    getDataSink?: {
+        __typename?: 'DataSink';
+        id: string;
+        workspaceId: string;
+        name?: string | null;
+        key: string;
+        version: number;
+        alerts?: Array<{
+            __typename?: 'DataSinkAlert';
+            id: string;
+            name: string;
+            condition: string;
+            conditionType: Types.DataSinkAlertConditionType;
+            severity: Types.AlertSeverity;
+            channels: Array<string>;
+            recipients: Array<string>;
+            enabled: boolean;
+            throttle?: {
+                __typename?: 'AlertThrottle';
+                enabled: boolean;
+                windowMinutes: number;
+                maxAlertsPerWindow: number;
+            } | null;
+            deliveries: Array<{
+                __typename?: 'DataSinkAlertDelivery';
+                channel: Types.DataSinkAlertChannel;
+                channelId: string;
+                recipient: string;
+            }>;
+        }> | null;
+    } | null;
+};
+export type BigConsoleDataSinkAlertChannelsQueryVariables = Types.Exact<{
+    dataSinkId: Types.Scalars['ID']['input'];
+}>;
+export type BigConsoleDataSinkAlertChannelsQuery = {
+    __typename?: 'Query';
+    dataSinkAlertChannels: Array<{
+        __typename?: 'DataSinkAlertConfiguredChannel';
+        id: string;
+        name: string;
+        platform: Types.DataSinkAlertChannel;
+        status: string;
+    }>;
+};
+export type BigConsoleDataSinkAlertExecutionsQueryVariables = Types.Exact<{
+    dataSinkId: Types.Scalars['ID']['input'];
+    alertId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+    first: Types.Scalars['Int']['input'];
+    after?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+}>;
+export type BigConsoleDataSinkAlertExecutionsQuery = {
+    __typename?: 'Query';
+    dataSinkAlertExecutions: Array<{
+        __typename?: 'DataSinkAlertExecution';
+        id: string;
+        alertId: string;
+        dataSinkId: string;
+        version: number;
+        source: string;
+        status: Types.DataSinkAlertExecutionStatus;
+        matched: boolean;
+        error?: string | null;
+        durationMs: number;
+        createdAt: string;
+        completedAt?: string | null;
+        deliveries: Array<{
+            __typename?: 'DataSinkAlertDeliveryAttempt';
+            channel: Types.DataSinkAlertChannel;
+            channelId: string;
+            recipient: string;
+            notificationId?: string | null;
+            status: string;
+            error?: string | null;
+            attemptedAt?: string | null;
+        }>;
+    }>;
+};
+export type BigConsolePreviewDataSinkAlertQueryVariables = Types.Exact<{
+    dataSinkId: Types.Scalars['ID']['input'];
+    condition: Types.Scalars['String']['input'];
+    conditionType: Types.DataSinkAlertConditionType;
+}>;
+export type BigConsolePreviewDataSinkAlertQuery = {
+    __typename?: 'Query';
+    previewDataSinkAlert: {
+        __typename?: 'DataSinkAlertPreview';
+        matched: boolean;
+        result?: Record<string, unknown> | null;
+        error?: string | null;
+        durationMs: number;
+        version: number;
+    };
+};
 export type GetDataSinkQueryVariables = Types.Exact<{
     id?: Types.InputMaybe<Types.Scalars['ID']['input']>;
     key?: Types.InputMaybe<Types.Scalars['String']['input']>;
@@ -6602,6 +6802,18 @@ export type ListWorkflowsQuery = {
         }>;
     }>;
 };
+export type WorkflowDefinitionExistsQueryVariables = Types.Exact<{
+    workflowKey: Types.Scalars['String']['input'];
+}>;
+export type WorkflowDefinitionExistsQuery = {
+    __typename?: 'Query';
+    workflowDefinition?: {
+        __typename?: 'WorkflowDefinition';
+        id: string;
+        workflowKey: string;
+        version: string;
+    } | null;
+};
 export declare const EntityCommentFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const DashboardCoreFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const DashboardEmbedPolicyFieldsFragmentDoc: Apollo.DocumentNode;
@@ -6615,6 +6827,7 @@ export declare const DashboardTemplateFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const DashboardTemplateListItemFragmentDoc: Apollo.DocumentNode;
 export declare const DashboardViewFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const PageInfoFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const BigConsoleAlertRuleFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const DataSinkDataStatsFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const DataSinkCoreFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const RefreshScheduleFieldsFragmentDoc: Apollo.DocumentNode;
@@ -8286,6 +8499,56 @@ export declare function useBatchDeleteDataSinksMutation(baseOptions?: ApolloReac
 export type BatchDeleteDataSinksMutationHookResult = ReturnType<typeof useBatchDeleteDataSinksMutation>;
 export type BatchDeleteDataSinksMutationResult = Apollo.MutationResult<Types.BatchDeleteDataSinksMutation>;
 export type BatchDeleteDataSinksMutationOptions = Apollo.BaseMutationOptions<Types.BatchDeleteDataSinksMutation, Types.BatchDeleteDataSinksMutationVariables>;
+export declare const BigConsoleUpsertDataSinkAlertDocument: Apollo.DocumentNode;
+export type BigConsoleUpsertDataSinkAlertMutationFn = Apollo.MutationFunction<Types.BigConsoleUpsertDataSinkAlertMutation, Types.BigConsoleUpsertDataSinkAlertMutationVariables>;
+/**
+ * __useBigConsoleUpsertDataSinkAlertMutation__
+ *
+ * To run a mutation, you first call `useBigConsoleUpsertDataSinkAlertMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBigConsoleUpsertDataSinkAlertMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [bigConsoleUpsertDataSinkAlertMutation, { data, loading, error }] = useBigConsoleUpsertDataSinkAlertMutation({
+ *   variables: {
+ *      dataSinkId: // value for 'dataSinkId'
+ *      alert: // value for 'alert'
+ *      expectedVersion: // value for 'expectedVersion'
+ *   },
+ * });
+ */
+export declare function useBigConsoleUpsertDataSinkAlertMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BigConsoleUpsertDataSinkAlertMutation, Types.BigConsoleUpsertDataSinkAlertMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BigConsoleUpsertDataSinkAlertMutation, any, Apollo.ApolloCache, undefined>;
+export type BigConsoleUpsertDataSinkAlertMutationHookResult = ReturnType<typeof useBigConsoleUpsertDataSinkAlertMutation>;
+export type BigConsoleUpsertDataSinkAlertMutationResult = Apollo.MutationResult<Types.BigConsoleUpsertDataSinkAlertMutation>;
+export type BigConsoleUpsertDataSinkAlertMutationOptions = Apollo.BaseMutationOptions<Types.BigConsoleUpsertDataSinkAlertMutation, Types.BigConsoleUpsertDataSinkAlertMutationVariables>;
+export declare const BigConsoleDeleteDataSinkAlertDocument: Apollo.DocumentNode;
+export type BigConsoleDeleteDataSinkAlertMutationFn = Apollo.MutationFunction<Types.BigConsoleDeleteDataSinkAlertMutation, Types.BigConsoleDeleteDataSinkAlertMutationVariables>;
+/**
+ * __useBigConsoleDeleteDataSinkAlertMutation__
+ *
+ * To run a mutation, you first call `useBigConsoleDeleteDataSinkAlertMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBigConsoleDeleteDataSinkAlertMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [bigConsoleDeleteDataSinkAlertMutation, { data, loading, error }] = useBigConsoleDeleteDataSinkAlertMutation({
+ *   variables: {
+ *      dataSinkId: // value for 'dataSinkId'
+ *      alertId: // value for 'alertId'
+ *      expectedVersion: // value for 'expectedVersion'
+ *   },
+ * });
+ */
+export declare function useBigConsoleDeleteDataSinkAlertMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BigConsoleDeleteDataSinkAlertMutation, Types.BigConsoleDeleteDataSinkAlertMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BigConsoleDeleteDataSinkAlertMutation, any, Apollo.ApolloCache, undefined>;
+export type BigConsoleDeleteDataSinkAlertMutationHookResult = ReturnType<typeof useBigConsoleDeleteDataSinkAlertMutation>;
+export type BigConsoleDeleteDataSinkAlertMutationResult = Apollo.MutationResult<Types.BigConsoleDeleteDataSinkAlertMutation>;
+export type BigConsoleDeleteDataSinkAlertMutationOptions = Apollo.BaseMutationOptions<Types.BigConsoleDeleteDataSinkAlertMutation, Types.BigConsoleDeleteDataSinkAlertMutationVariables>;
 export declare const CreateDataSinkDocument: Apollo.DocumentNode;
 export type CreateDataSinkMutationFn = Apollo.MutationFunction<Types.CreateDataSinkMutation, Types.CreateDataSinkMutationVariables>;
 /**
@@ -8401,6 +8664,131 @@ export declare function useUpdateDataSinkMutation(baseOptions?: ApolloReactHooks
 export type UpdateDataSinkMutationHookResult = ReturnType<typeof useUpdateDataSinkMutation>;
 export type UpdateDataSinkMutationResult = Apollo.MutationResult<Types.UpdateDataSinkMutation>;
 export type UpdateDataSinkMutationOptions = Apollo.BaseMutationOptions<Types.UpdateDataSinkMutation, Types.UpdateDataSinkMutationVariables>;
+export declare const BigConsoleDataSinkAlertsDocument: Apollo.DocumentNode;
+/**
+ * __useBigConsoleDataSinkAlertsQuery__
+ *
+ * To run a query within a React component, call `useBigConsoleDataSinkAlertsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useBigConsoleDataSinkAlertsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useBigConsoleDataSinkAlertsQuery({
+ *   variables: {
+ *      dataSinkId: // value for 'dataSinkId'
+ *   },
+ * });
+ */
+export declare function useBigConsoleDataSinkAlertsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.BigConsoleDataSinkAlertsQuery, Types.BigConsoleDataSinkAlertsQueryVariables> & ({
+    variables: Types.BigConsoleDataSinkAlertsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.BigConsoleDataSinkAlertsQuery, Types.BigConsoleDataSinkAlertsQueryVariables, "empty" | "complete" | "streaming", Types.BigConsoleDataSinkAlertsQueryVariables>;
+export declare function useBigConsoleDataSinkAlertsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.BigConsoleDataSinkAlertsQuery, Types.BigConsoleDataSinkAlertsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.BigConsoleDataSinkAlertsQuery, Types.BigConsoleDataSinkAlertsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useBigConsoleDataSinkAlertsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.BigConsoleDataSinkAlertsQuery, Types.BigConsoleDataSinkAlertsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BigConsoleDataSinkAlertsQuery, Types.BigConsoleDataSinkAlertsQueryVariables>;
+export declare function useBigConsoleDataSinkAlertsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.BigConsoleDataSinkAlertsQuery, Types.BigConsoleDataSinkAlertsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BigConsoleDataSinkAlertsQuery | undefined, Types.BigConsoleDataSinkAlertsQueryVariables>;
+export type BigConsoleDataSinkAlertsQueryHookResult = ReturnType<typeof useBigConsoleDataSinkAlertsQuery>;
+export type BigConsoleDataSinkAlertsLazyQueryHookResult = ReturnType<typeof useBigConsoleDataSinkAlertsLazyQuery>;
+export type BigConsoleDataSinkAlertsSuspenseQueryHookResult = ReturnType<typeof useBigConsoleDataSinkAlertsSuspenseQuery>;
+export type BigConsoleDataSinkAlertsQueryResult = Apollo.QueryResult<Types.BigConsoleDataSinkAlertsQuery, Types.BigConsoleDataSinkAlertsQueryVariables>;
+export declare const BigConsoleDataSinkAlertChannelsDocument: Apollo.DocumentNode;
+/**
+ * __useBigConsoleDataSinkAlertChannelsQuery__
+ *
+ * To run a query within a React component, call `useBigConsoleDataSinkAlertChannelsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useBigConsoleDataSinkAlertChannelsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useBigConsoleDataSinkAlertChannelsQuery({
+ *   variables: {
+ *      dataSinkId: // value for 'dataSinkId'
+ *   },
+ * });
+ */
+export declare function useBigConsoleDataSinkAlertChannelsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.BigConsoleDataSinkAlertChannelsQuery, Types.BigConsoleDataSinkAlertChannelsQueryVariables> & ({
+    variables: Types.BigConsoleDataSinkAlertChannelsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.BigConsoleDataSinkAlertChannelsQuery, Types.BigConsoleDataSinkAlertChannelsQueryVariables, "empty" | "complete" | "streaming", Types.BigConsoleDataSinkAlertChannelsQueryVariables>;
+export declare function useBigConsoleDataSinkAlertChannelsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.BigConsoleDataSinkAlertChannelsQuery, Types.BigConsoleDataSinkAlertChannelsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.BigConsoleDataSinkAlertChannelsQuery, Types.BigConsoleDataSinkAlertChannelsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useBigConsoleDataSinkAlertChannelsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.BigConsoleDataSinkAlertChannelsQuery, Types.BigConsoleDataSinkAlertChannelsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BigConsoleDataSinkAlertChannelsQuery, Types.BigConsoleDataSinkAlertChannelsQueryVariables>;
+export declare function useBigConsoleDataSinkAlertChannelsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.BigConsoleDataSinkAlertChannelsQuery, Types.BigConsoleDataSinkAlertChannelsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BigConsoleDataSinkAlertChannelsQuery | undefined, Types.BigConsoleDataSinkAlertChannelsQueryVariables>;
+export type BigConsoleDataSinkAlertChannelsQueryHookResult = ReturnType<typeof useBigConsoleDataSinkAlertChannelsQuery>;
+export type BigConsoleDataSinkAlertChannelsLazyQueryHookResult = ReturnType<typeof useBigConsoleDataSinkAlertChannelsLazyQuery>;
+export type BigConsoleDataSinkAlertChannelsSuspenseQueryHookResult = ReturnType<typeof useBigConsoleDataSinkAlertChannelsSuspenseQuery>;
+export type BigConsoleDataSinkAlertChannelsQueryResult = Apollo.QueryResult<Types.BigConsoleDataSinkAlertChannelsQuery, Types.BigConsoleDataSinkAlertChannelsQueryVariables>;
+export declare const BigConsoleDataSinkAlertExecutionsDocument: Apollo.DocumentNode;
+/**
+ * __useBigConsoleDataSinkAlertExecutionsQuery__
+ *
+ * To run a query within a React component, call `useBigConsoleDataSinkAlertExecutionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useBigConsoleDataSinkAlertExecutionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useBigConsoleDataSinkAlertExecutionsQuery({
+ *   variables: {
+ *      dataSinkId: // value for 'dataSinkId'
+ *      alertId: // value for 'alertId'
+ *      first: // value for 'first'
+ *      after: // value for 'after'
+ *   },
+ * });
+ */
+export declare function useBigConsoleDataSinkAlertExecutionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.BigConsoleDataSinkAlertExecutionsQuery, Types.BigConsoleDataSinkAlertExecutionsQueryVariables> & ({
+    variables: Types.BigConsoleDataSinkAlertExecutionsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.BigConsoleDataSinkAlertExecutionsQuery, Types.BigConsoleDataSinkAlertExecutionsQueryVariables, "empty" | "complete" | "streaming", Types.BigConsoleDataSinkAlertExecutionsQueryVariables>;
+export declare function useBigConsoleDataSinkAlertExecutionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.BigConsoleDataSinkAlertExecutionsQuery, Types.BigConsoleDataSinkAlertExecutionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.BigConsoleDataSinkAlertExecutionsQuery, Types.BigConsoleDataSinkAlertExecutionsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useBigConsoleDataSinkAlertExecutionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.BigConsoleDataSinkAlertExecutionsQuery, Types.BigConsoleDataSinkAlertExecutionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BigConsoleDataSinkAlertExecutionsQuery, Types.BigConsoleDataSinkAlertExecutionsQueryVariables>;
+export declare function useBigConsoleDataSinkAlertExecutionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.BigConsoleDataSinkAlertExecutionsQuery, Types.BigConsoleDataSinkAlertExecutionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BigConsoleDataSinkAlertExecutionsQuery | undefined, Types.BigConsoleDataSinkAlertExecutionsQueryVariables>;
+export type BigConsoleDataSinkAlertExecutionsQueryHookResult = ReturnType<typeof useBigConsoleDataSinkAlertExecutionsQuery>;
+export type BigConsoleDataSinkAlertExecutionsLazyQueryHookResult = ReturnType<typeof useBigConsoleDataSinkAlertExecutionsLazyQuery>;
+export type BigConsoleDataSinkAlertExecutionsSuspenseQueryHookResult = ReturnType<typeof useBigConsoleDataSinkAlertExecutionsSuspenseQuery>;
+export type BigConsoleDataSinkAlertExecutionsQueryResult = Apollo.QueryResult<Types.BigConsoleDataSinkAlertExecutionsQuery, Types.BigConsoleDataSinkAlertExecutionsQueryVariables>;
+export declare const BigConsolePreviewDataSinkAlertDocument: Apollo.DocumentNode;
+/**
+ * __useBigConsolePreviewDataSinkAlertQuery__
+ *
+ * To run a query within a React component, call `useBigConsolePreviewDataSinkAlertQuery` and pass it any options that fit your needs.
+ * When your component renders, `useBigConsolePreviewDataSinkAlertQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useBigConsolePreviewDataSinkAlertQuery({
+ *   variables: {
+ *      dataSinkId: // value for 'dataSinkId'
+ *      condition: // value for 'condition'
+ *      conditionType: // value for 'conditionType'
+ *   },
+ * });
+ */
+export declare function useBigConsolePreviewDataSinkAlertQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.BigConsolePreviewDataSinkAlertQuery, Types.BigConsolePreviewDataSinkAlertQueryVariables> & ({
+    variables: Types.BigConsolePreviewDataSinkAlertQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.BigConsolePreviewDataSinkAlertQuery, Types.BigConsolePreviewDataSinkAlertQueryVariables, "empty" | "complete" | "streaming", Types.BigConsolePreviewDataSinkAlertQueryVariables>;
+export declare function useBigConsolePreviewDataSinkAlertLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.BigConsolePreviewDataSinkAlertQuery, Types.BigConsolePreviewDataSinkAlertQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.BigConsolePreviewDataSinkAlertQuery, Types.BigConsolePreviewDataSinkAlertQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useBigConsolePreviewDataSinkAlertSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.BigConsolePreviewDataSinkAlertQuery, Types.BigConsolePreviewDataSinkAlertQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BigConsolePreviewDataSinkAlertQuery, Types.BigConsolePreviewDataSinkAlertQueryVariables>;
+export declare function useBigConsolePreviewDataSinkAlertSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.BigConsolePreviewDataSinkAlertQuery, Types.BigConsolePreviewDataSinkAlertQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.BigConsolePreviewDataSinkAlertQuery | undefined, Types.BigConsolePreviewDataSinkAlertQueryVariables>;
+export type BigConsolePreviewDataSinkAlertQueryHookResult = ReturnType<typeof useBigConsolePreviewDataSinkAlertQuery>;
+export type BigConsolePreviewDataSinkAlertLazyQueryHookResult = ReturnType<typeof useBigConsolePreviewDataSinkAlertLazyQuery>;
+export type BigConsolePreviewDataSinkAlertSuspenseQueryHookResult = ReturnType<typeof useBigConsolePreviewDataSinkAlertSuspenseQuery>;
+export type BigConsolePreviewDataSinkAlertQueryResult = Apollo.QueryResult<Types.BigConsolePreviewDataSinkAlertQuery, Types.BigConsolePreviewDataSinkAlertQueryVariables>;
 export declare const GetDataSinkDocument: Apollo.DocumentNode;
 /**
  * __useGetDataSinkQuery__
@@ -10734,4 +11122,34 @@ export type ListWorkflowsQueryHookResult = ReturnType<typeof useListWorkflowsQue
 export type ListWorkflowsLazyQueryHookResult = ReturnType<typeof useListWorkflowsLazyQuery>;
 export type ListWorkflowsSuspenseQueryHookResult = ReturnType<typeof useListWorkflowsSuspenseQuery>;
 export type ListWorkflowsQueryResult = Apollo.QueryResult<Types.ListWorkflowsQuery, Types.ListWorkflowsQueryVariables>;
+export declare const WorkflowDefinitionExistsDocument: Apollo.DocumentNode;
+/**
+ * __useWorkflowDefinitionExistsQuery__
+ *
+ * To run a query within a React component, call `useWorkflowDefinitionExistsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useWorkflowDefinitionExistsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useWorkflowDefinitionExistsQuery({
+ *   variables: {
+ *      workflowKey: // value for 'workflowKey'
+ *   },
+ * });
+ */
+export declare function useWorkflowDefinitionExistsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.WorkflowDefinitionExistsQuery, Types.WorkflowDefinitionExistsQueryVariables> & ({
+    variables: Types.WorkflowDefinitionExistsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.WorkflowDefinitionExistsQuery, Types.WorkflowDefinitionExistsQueryVariables, "empty" | "complete" | "streaming", Types.WorkflowDefinitionExistsQueryVariables>;
+export declare function useWorkflowDefinitionExistsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.WorkflowDefinitionExistsQuery, Types.WorkflowDefinitionExistsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.WorkflowDefinitionExistsQuery, Types.WorkflowDefinitionExistsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useWorkflowDefinitionExistsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkflowDefinitionExistsQuery, Types.WorkflowDefinitionExistsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkflowDefinitionExistsQuery, Types.WorkflowDefinitionExistsQueryVariables>;
+export declare function useWorkflowDefinitionExistsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkflowDefinitionExistsQuery, Types.WorkflowDefinitionExistsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkflowDefinitionExistsQuery | undefined, Types.WorkflowDefinitionExistsQueryVariables>;
+export type WorkflowDefinitionExistsQueryHookResult = ReturnType<typeof useWorkflowDefinitionExistsQuery>;
+export type WorkflowDefinitionExistsLazyQueryHookResult = ReturnType<typeof useWorkflowDefinitionExistsLazyQuery>;
+export type WorkflowDefinitionExistsSuspenseQueryHookResult = ReturnType<typeof useWorkflowDefinitionExistsSuspenseQuery>;
+export type WorkflowDefinitionExistsQueryResult = Apollo.QueryResult<Types.WorkflowDefinitionExistsQuery, Types.WorkflowDefinitionExistsQueryVariables>;
 //# sourceMappingURL=wspace-operations.d.ts.map