diff --git a/frontend/libs/console/legacy-ce/src/lib/components/Services/Data/DataSources/CreateDataSource/Neon/useCreateHasuraCloudDatasource.ts b/frontend/libs/console/legacy-ce/src/lib/components/Services/Data/DataSources/CreateDataSource/Neon/useCreateHasuraCloudDatasource.ts index d056c770043..4946d0552bf 100644 --- a/frontend/libs/console/legacy-ce/src/lib/components/Services/Data/DataSources/CreateDataSource/Neon/useCreateHasuraCloudDatasource.ts +++ b/frontend/libs/console/legacy-ce/src/lib/components/Services/Data/DataSources/CreateDataSource/Neon/useCreateHasuraCloudDatasource.ts @@ -16,6 +16,7 @@ import Globals from '../../../../../../Globals'; import { controlPlaneClient, FETCH_CONFIG_STATUS, + FetchConfigStatusSubscription, } from '../../../../../../features/ControlPlane'; type HasuraDBCreationPayload = { @@ -162,46 +163,58 @@ export function useCreateHasuraCloudDatasource( * If the change has not propagated to a worker to which the `pg_add_source` request is routed to, * the server would throw an `inconsistent_object` error as the new env var will not be found. * - * To handle this, we wait for the changes to be propagated to all + * To handle this, we wait for the changes to be propagated to all the live hasura * workers of a tenant before attempting to connect the DB. * * We do that by verifying that the new config hash has been set - * for all workers of the tenant using the `config_status` table. + * for all the live workers of the tenant using the `config_status` table + * + * Hash is compared against the `config_status` table and worker status + * is checked against the `hasura_worker` table * * Additionally add a timeout interval with retries as an additional * redundancy since it throws CORS error locally */ - const { unsubscribe } = controlPlaneClient.subscribe( - FETCH_CONFIG_STATUS, - { - tenantId: Globals.hasuraCloudTenantId, - }, - data => { - if ( - // check if all workers are successfully configured with the new hash - data.config_status.every( - (config: { hash: string; message: string }) => - config.message === 'Service configured successfully' && - config.hash !== oldConfigHash - ) - ) { - verifyProjectHealthAndConnectDataSource( - successCallback, - errorCallback - ); + const { unsubscribe } = + controlPlaneClient.subscribe( + FETCH_CONFIG_STATUS, + { + tenantId: Globals.hasuraCloudTenantId, + }, + data => { + const configStatusData = data.hasura_worker + .map(config_status_obj => + config_status_obj.config_statuses.map( + config_data => config_data + ) + ) + .flat(1); + + if ( + // check if all workers are successfully configured with the new hash + configStatusData.every( + config => + config.message === 'Service configured successfully' && + config.hash !== oldConfigHash + ) + ) { + verifyProjectHealthAndConnectDataSource( + successCallback, + errorCallback + ); + unsubscribe(); + } + }, + error => { + programmaticallyTraceError({ + error: + 'failed subscribing to fetch_config_status while connecting neon database', + cause: error, + }); + errorCallback(); unsubscribe(); } - }, - error => { - programmaticallyTraceError({ - error: - 'failed subscribing to fetch_config_status while connecting neon database', - cause: error, - }); - errorCallback(); - unsubscribe(); - } - ); + ); }) .catch(error => { // if adding env var fails unexpectedly, set the error state diff --git a/frontend/libs/console/legacy-ce/src/lib/components/Services/Data/DataSources/CreateDataSource/utils.ts b/frontend/libs/console/legacy-ce/src/lib/components/Services/Data/DataSources/CreateDataSource/utils.ts index 98d17eb872a..a2a4540b64a 100644 --- a/frontend/libs/console/legacy-ce/src/lib/components/Services/Data/DataSources/CreateDataSource/utils.ts +++ b/frontend/libs/console/legacy-ce/src/lib/components/Services/Data/DataSources/CreateDataSource/utils.ts @@ -94,7 +94,7 @@ export const updateEnvVars = ( if (response.errors) { throw new Error(response.errors[0]?.message); } else { - return response.updateTenantEnv; + return response.data.updateTenantEnv; } }); }) diff --git a/frontend/libs/console/legacy-ce/src/lib/features/ControlPlane/generatedGraphQLTypes.ts b/frontend/libs/console/legacy-ce/src/lib/features/ControlPlane/generatedGraphQLTypes.ts index fb94a00edb7..5091dff2f10 100644 --- a/frontend/libs/console/legacy-ce/src/lib/features/ControlPlane/generatedGraphQLTypes.ts +++ b/frontend/libs/console/legacy-ce/src/lib/features/ControlPlane/generatedGraphQLTypes.ts @@ -16,9 +16,10 @@ export type Scalars = { Boolean: boolean; Int: number; Float: number; - jsonb: any; timestamptz: any; + json: any; uuid: any; + jsonb: any; project_activity_status_enum: any; citext: any; bigint: any; @@ -30,8 +31,10 @@ export type Scalars = { _text: any; opentelemetry_connection_type_enum: any; date: any; - json: any; _uuid: any; + connector_timestamptz: any; + connector_uuid: any; + connector_deployment_status: any; bytea: any; _json: any; smallint: any; @@ -98,6 +101,1103 @@ export type AddProjectResponse = { id: Scalars['uuid']; }; +/** Alert configuration for Hasura Cloud projects */ +export type Alert_Config = { + __typename?: 'alert_config'; + /** An array relationship */ + alert_config_services: Array; + /** An aggregate relationship */ + alert_config_services_aggregate: Alert_Config_Service_Aggregate; + /** An array relationship */ + alert_types: Array; + /** An aggregate relationship */ + alert_types_aggregate: Alert_Config_Alert_Type_Aggregate; + created_at: Scalars['timestamptz']; + enabled: Scalars['Boolean']; + /** An object relationship */ + project: Projects; + project_id: Scalars['uuid']; + /** An array relationship */ + slack_alert_configs: Array; + /** An aggregate relationship */ + slack_alert_configs_aggregate: Slack_Config_Aggregate; + /** An object relationship */ + tenant?: Maybe; + updated_at: Scalars['timestamptz']; +}; + +/** Alert configuration for Hasura Cloud projects */ +export type Alert_ConfigAlert_Config_ServicesArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +/** Alert configuration for Hasura Cloud projects */ +export type Alert_ConfigAlert_Config_Services_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +/** Alert configuration for Hasura Cloud projects */ +export type Alert_ConfigAlert_TypesArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +/** Alert configuration for Hasura Cloud projects */ +export type Alert_ConfigAlert_Types_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +/** Alert configuration for Hasura Cloud projects */ +export type Alert_ConfigSlack_Alert_ConfigsArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +/** Alert configuration for Hasura Cloud projects */ +export type Alert_ConfigSlack_Alert_Configs_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +/** aggregated selection of "alert_config" */ +export type Alert_Config_Aggregate = { + __typename?: 'alert_config_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "alert_config" */ +export type Alert_Config_Aggregate_Fields = { + __typename?: 'alert_config_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "alert_config" */ +export type Alert_Config_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** Enabled alert types for Hasura Cloud projects */ +export type Alert_Config_Alert_Type = { + __typename?: 'alert_config_alert_type'; + /** An object relationship */ + alert_config: Alert_Config; + /** An object relationship */ + alert_type: Alert_Type; + created_at: Scalars['timestamptz']; + /** An object relationship */ + project?: Maybe; + project_id: Scalars['uuid']; + rules?: Maybe; + /** An object relationship */ + slack_config?: Maybe; + type: Scalars['String']; +}; + +/** Enabled alert types for Hasura Cloud projects */ +export type Alert_Config_Alert_TypeRulesArgs = { + path?: Maybe; +}; + +/** aggregated selection of "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Aggregate = { + __typename?: 'alert_config_alert_type_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +export type Alert_Config_Alert_Type_Aggregate_Bool_Exp = { + count?: Maybe; +}; + +export type Alert_Config_Alert_Type_Aggregate_Bool_Exp_Count = { + arguments?: Maybe>; + distinct?: Maybe; + filter?: Maybe; + predicate: Int_Comparison_Exp; +}; + +/** aggregate fields of "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Aggregate_Fields = { + __typename?: 'alert_config_alert_type_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** order by aggregate values of table "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Aggregate_Order_By = { + count?: Maybe; + max?: Maybe; + min?: Maybe; +}; + +/** input type for inserting array relation for remote table "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Arr_Rel_Insert_Input = { + data: Array; + /** upsert condition */ + on_conflict?: Maybe; +}; + +/** Boolean expression to filter rows from the table "alert_config_alert_type". All fields are combined with a logical 'AND'. */ +export type Alert_Config_Alert_Type_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + alert_config?: Maybe; + alert_type?: Maybe; + created_at?: Maybe; + project?: Maybe; + project_id?: Maybe; + rules?: Maybe; + slack_config?: Maybe; + type?: Maybe; +}; + +/** unique or primary key constraints on table "alert_config_alert_type" */ +export enum Alert_Config_Alert_Type_Constraint { + /** unique or primary key constraint on columns "type", "project_id" */ + AlertConfigAlertTypePkey = 'alert_config_alert_type_pkey', +} + +/** input type for inserting data into table "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Insert_Input = { + alert_config?: Maybe; + alert_type?: Maybe; + created_at?: Maybe; + project?: Maybe; + project_id?: Maybe; + rules?: Maybe; + slack_config?: Maybe; + type?: Maybe; +}; + +/** aggregate max on columns */ +export type Alert_Config_Alert_Type_Max_Fields = { + __typename?: 'alert_config_alert_type_max_fields'; + created_at?: Maybe; + project_id?: Maybe; + type?: Maybe; +}; + +/** order by max() on columns of table "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Max_Order_By = { + created_at?: Maybe; + project_id?: Maybe; + type?: Maybe; +}; + +/** aggregate min on columns */ +export type Alert_Config_Alert_Type_Min_Fields = { + __typename?: 'alert_config_alert_type_min_fields'; + created_at?: Maybe; + project_id?: Maybe; + type?: Maybe; +}; + +/** order by min() on columns of table "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Min_Order_By = { + created_at?: Maybe; + project_id?: Maybe; + type?: Maybe; +}; + +/** response of any mutation on the table "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Mutation_Response = { + __typename?: 'alert_config_alert_type_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** on_conflict condition type for table "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_On_Conflict = { + constraint: Alert_Config_Alert_Type_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "alert_config_alert_type". */ +export type Alert_Config_Alert_Type_Order_By = { + alert_config?: Maybe; + alert_type?: Maybe; + created_at?: Maybe; + project?: Maybe; + project_id?: Maybe; + rules?: Maybe; + slack_config?: Maybe; + type?: Maybe; +}; + +/** primary key columns input for table: alert_config_alert_type */ +export type Alert_Config_Alert_Type_Pk_Columns_Input = { + project_id: Scalars['uuid']; + type: Scalars['String']; +}; + +/** select columns of table "alert_config_alert_type" */ +export enum Alert_Config_Alert_Type_Select_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + ProjectId = 'project_id', + /** column name */ + Rules = 'rules', + /** column name */ + Type = 'type', +} + +/** input type for updating data in table "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Set_Input = { + created_at?: Maybe; + project_id?: Maybe; + rules?: Maybe; + type?: Maybe; +}; + +/** Streaming cursor of the table "alert_config_alert_type" */ +export type Alert_Config_Alert_Type_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Alert_Config_Alert_Type_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Alert_Config_Alert_Type_Stream_Cursor_Value_Input = { + created_at?: Maybe; + project_id?: Maybe; + rules?: Maybe; + type?: Maybe; +}; + +/** update columns of table "alert_config_alert_type" */ +export enum Alert_Config_Alert_Type_Update_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + ProjectId = 'project_id', + /** column name */ + Rules = 'rules', + /** column name */ + Type = 'type', +} + +export type Alert_Config_Alert_Type_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Alert_Config_Alert_Type_Bool_Exp; +}; + +/** Boolean expression to filter rows from the table "alert_config". All fields are combined with a logical 'AND'. */ +export type Alert_Config_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + alert_config_services?: Maybe; + alert_config_services_aggregate?: Maybe; + alert_types?: Maybe; + alert_types_aggregate?: Maybe; + created_at?: Maybe; + enabled?: Maybe; + project?: Maybe; + project_id?: Maybe; + slack_alert_configs?: Maybe; + slack_alert_configs_aggregate?: Maybe; + tenant?: Maybe; + updated_at?: Maybe; +}; + +/** unique or primary key constraints on table "alert_config" */ +export enum Alert_Config_Constraint { + /** unique or primary key constraint on columns "project_id" */ + AlertConfigPkey = 'alert_config_pkey', +} + +/** input type for inserting data into table "alert_config" */ +export type Alert_Config_Insert_Input = { + alert_config_services?: Maybe; + alert_types?: Maybe; + created_at?: Maybe; + enabled?: Maybe; + project?: Maybe; + project_id?: Maybe; + slack_alert_configs?: Maybe; + tenant?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate max on columns */ +export type Alert_Config_Max_Fields = { + __typename?: 'alert_config_max_fields'; + created_at?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate min on columns */ +export type Alert_Config_Min_Fields = { + __typename?: 'alert_config_min_fields'; + created_at?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** response of any mutation on the table "alert_config" */ +export type Alert_Config_Mutation_Response = { + __typename?: 'alert_config_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** input type for inserting object relation for remote table "alert_config" */ +export type Alert_Config_Obj_Rel_Insert_Input = { + data: Alert_Config_Insert_Input; + /** upsert condition */ + on_conflict?: Maybe; +}; + +/** on_conflict condition type for table "alert_config" */ +export type Alert_Config_On_Conflict = { + constraint: Alert_Config_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "alert_config". */ +export type Alert_Config_Order_By = { + alert_config_services_aggregate?: Maybe; + alert_types_aggregate?: Maybe; + created_at?: Maybe; + enabled?: Maybe; + project?: Maybe; + project_id?: Maybe; + slack_alert_configs_aggregate?: Maybe; + tenant?: Maybe; + updated_at?: Maybe; +}; + +/** primary key columns input for table: alert_config */ +export type Alert_Config_Pk_Columns_Input = { + project_id: Scalars['uuid']; +}; + +/** select columns of table "alert_config" */ +export enum Alert_Config_Select_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Enabled = 'enabled', + /** column name */ + ProjectId = 'project_id', + /** column name */ + UpdatedAt = 'updated_at', +} + +/** Alert notification service configs for Hasura Cloud projects */ +export type Alert_Config_Service = { + __typename?: 'alert_config_service'; + /** An object relationship */ + alert_config: Alert_Config; + created_at: Scalars['timestamptz']; + enabled: Scalars['Boolean']; + metadata?: Maybe; + /** An object relationship */ + project?: Maybe; + project_id: Scalars['uuid']; + rules?: Maybe; + type: Alert_Service_Type_Enum; + updated_at: Scalars['timestamptz']; +}; + +/** Alert notification service configs for Hasura Cloud projects */ +export type Alert_Config_ServiceMetadataArgs = { + path?: Maybe; +}; + +/** Alert notification service configs for Hasura Cloud projects */ +export type Alert_Config_ServiceRulesArgs = { + path?: Maybe; +}; + +/** aggregated selection of "alert_config_service" */ +export type Alert_Config_Service_Aggregate = { + __typename?: 'alert_config_service_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +export type Alert_Config_Service_Aggregate_Bool_Exp = { + bool_and?: Maybe; + bool_or?: Maybe; + count?: Maybe; +}; + +export type Alert_Config_Service_Aggregate_Bool_Exp_Bool_And = { + arguments: Alert_Config_Service_Select_Column_Alert_Config_Service_Aggregate_Bool_Exp_Bool_And_Arguments_Columns; + distinct?: Maybe; + filter?: Maybe; + predicate: Boolean_Comparison_Exp; +}; + +export type Alert_Config_Service_Aggregate_Bool_Exp_Bool_Or = { + arguments: Alert_Config_Service_Select_Column_Alert_Config_Service_Aggregate_Bool_Exp_Bool_Or_Arguments_Columns; + distinct?: Maybe; + filter?: Maybe; + predicate: Boolean_Comparison_Exp; +}; + +export type Alert_Config_Service_Aggregate_Bool_Exp_Count = { + arguments?: Maybe>; + distinct?: Maybe; + filter?: Maybe; + predicate: Int_Comparison_Exp; +}; + +/** aggregate fields of "alert_config_service" */ +export type Alert_Config_Service_Aggregate_Fields = { + __typename?: 'alert_config_service_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "alert_config_service" */ +export type Alert_Config_Service_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** order by aggregate values of table "alert_config_service" */ +export type Alert_Config_Service_Aggregate_Order_By = { + count?: Maybe; + max?: Maybe; + min?: Maybe; +}; + +/** append existing jsonb value of filtered columns with new jsonb value */ +export type Alert_Config_Service_Append_Input = { + rules?: Maybe; +}; + +/** input type for inserting array relation for remote table "alert_config_service" */ +export type Alert_Config_Service_Arr_Rel_Insert_Input = { + data: Array; + /** upsert condition */ + on_conflict?: Maybe; +}; + +/** Boolean expression to filter rows from the table "alert_config_service". All fields are combined with a logical 'AND'. */ +export type Alert_Config_Service_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + alert_config?: Maybe; + created_at?: Maybe; + enabled?: Maybe; + metadata?: Maybe; + project?: Maybe; + project_id?: Maybe; + rules?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** unique or primary key constraints on table "alert_config_service" */ +export enum Alert_Config_Service_Constraint { + /** unique or primary key constraint on columns "type", "project_id" */ + AlertConfigServicePkey = 'alert_config_service_pkey', +} + +/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */ +export type Alert_Config_Service_Delete_At_Path_Input = { + rules?: Maybe>; +}; + +/** + * delete the array element with specified index (negative integers count from the + * end). throws an error if top level container is not an array + */ +export type Alert_Config_Service_Delete_Elem_Input = { + rules?: Maybe; +}; + +/** delete key/value pair or string element. key/value pairs are matched based on their key value */ +export type Alert_Config_Service_Delete_Key_Input = { + rules?: Maybe; +}; + +/** input type for inserting data into table "alert_config_service" */ +export type Alert_Config_Service_Insert_Input = { + alert_config?: Maybe; + created_at?: Maybe; + enabled?: Maybe; + metadata?: Maybe; + project?: Maybe; + project_id?: Maybe; + rules?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate max on columns */ +export type Alert_Config_Service_Max_Fields = { + __typename?: 'alert_config_service_max_fields'; + created_at?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** order by max() on columns of table "alert_config_service" */ +export type Alert_Config_Service_Max_Order_By = { + created_at?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate min on columns */ +export type Alert_Config_Service_Min_Fields = { + __typename?: 'alert_config_service_min_fields'; + created_at?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** order by min() on columns of table "alert_config_service" */ +export type Alert_Config_Service_Min_Order_By = { + created_at?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** response of any mutation on the table "alert_config_service" */ +export type Alert_Config_Service_Mutation_Response = { + __typename?: 'alert_config_service_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** on_conflict condition type for table "alert_config_service" */ +export type Alert_Config_Service_On_Conflict = { + constraint: Alert_Config_Service_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "alert_config_service". */ +export type Alert_Config_Service_Order_By = { + alert_config?: Maybe; + created_at?: Maybe; + enabled?: Maybe; + metadata?: Maybe; + project?: Maybe; + project_id?: Maybe; + rules?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** primary key columns input for table: alert_config_service */ +export type Alert_Config_Service_Pk_Columns_Input = { + project_id: Scalars['uuid']; + type: Alert_Service_Type_Enum; +}; + +/** prepend existing jsonb value of filtered columns with new jsonb value */ +export type Alert_Config_Service_Prepend_Input = { + rules?: Maybe; +}; + +/** select columns of table "alert_config_service" */ +export enum Alert_Config_Service_Select_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Enabled = 'enabled', + /** column name */ + Metadata = 'metadata', + /** column name */ + ProjectId = 'project_id', + /** column name */ + Rules = 'rules', + /** column name */ + Type = 'type', + /** column name */ + UpdatedAt = 'updated_at', +} + +/** select "alert_config_service_aggregate_bool_exp_bool_and_arguments_columns" columns of table "alert_config_service" */ +export enum Alert_Config_Service_Select_Column_Alert_Config_Service_Aggregate_Bool_Exp_Bool_And_Arguments_Columns { + /** column name */ + Enabled = 'enabled', +} + +/** select "alert_config_service_aggregate_bool_exp_bool_or_arguments_columns" columns of table "alert_config_service" */ +export enum Alert_Config_Service_Select_Column_Alert_Config_Service_Aggregate_Bool_Exp_Bool_Or_Arguments_Columns { + /** column name */ + Enabled = 'enabled', +} + +/** input type for updating data in table "alert_config_service" */ +export type Alert_Config_Service_Set_Input = { + created_at?: Maybe; + enabled?: Maybe; + metadata?: Maybe; + project_id?: Maybe; + rules?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** Streaming cursor of the table "alert_config_service" */ +export type Alert_Config_Service_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Alert_Config_Service_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Alert_Config_Service_Stream_Cursor_Value_Input = { + created_at?: Maybe; + enabled?: Maybe; + metadata?: Maybe; + project_id?: Maybe; + rules?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** update columns of table "alert_config_service" */ +export enum Alert_Config_Service_Update_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Enabled = 'enabled', + /** column name */ + Metadata = 'metadata', + /** column name */ + ProjectId = 'project_id', + /** column name */ + Rules = 'rules', + /** column name */ + Type = 'type', + /** column name */ + UpdatedAt = 'updated_at', +} + +export type Alert_Config_Service_Updates = { + /** append existing jsonb value of filtered columns with new jsonb value */ + _append?: Maybe; + /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */ + _delete_at_path?: Maybe; + /** + * delete the array element with specified index (negative integers count from + * the end). throws an error if top level container is not an array + */ + _delete_elem?: Maybe; + /** delete key/value pair or string element. key/value pairs are matched based on their key value */ + _delete_key?: Maybe; + /** prepend existing jsonb value of filtered columns with new jsonb value */ + _prepend?: Maybe; + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Alert_Config_Service_Bool_Exp; +}; + +/** input type for updating data in table "alert_config" */ +export type Alert_Config_Set_Input = { + created_at?: Maybe; + enabled?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** Streaming cursor of the table "alert_config" */ +export type Alert_Config_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Alert_Config_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Alert_Config_Stream_Cursor_Value_Input = { + created_at?: Maybe; + enabled?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** update columns of table "alert_config" */ +export enum Alert_Config_Update_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Enabled = 'enabled', + /** column name */ + ProjectId = 'project_id', + /** column name */ + UpdatedAt = 'updated_at', +} + +export type Alert_Config_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Alert_Config_Bool_Exp; +}; + +/** Alert notification service type enum */ +export type Alert_Service_Type = { + __typename?: 'alert_service_type'; + description: Scalars['String']; + name: Scalars['String']; +}; + +/** aggregated selection of "alert_service_type" */ +export type Alert_Service_Type_Aggregate = { + __typename?: 'alert_service_type_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "alert_service_type" */ +export type Alert_Service_Type_Aggregate_Fields = { + __typename?: 'alert_service_type_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "alert_service_type" */ +export type Alert_Service_Type_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** Boolean expression to filter rows from the table "alert_service_type". All fields are combined with a logical 'AND'. */ +export type Alert_Service_Type_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + description?: Maybe; + name?: Maybe; +}; + +/** unique or primary key constraints on table "alert_service_type" */ +export enum Alert_Service_Type_Constraint { + /** unique or primary key constraint on columns "name" */ + AlertServiceTypePkey = 'alert_service_type_pkey', +} + +export enum Alert_Service_Type_Enum { + /** Mail */ + Mail = 'mail', + /** Slack Notifier */ + Slack = 'slack', +} + +/** Boolean expression to compare columns of type "alert_service_type_enum". All fields are combined with logical 'AND'. */ +export type Alert_Service_Type_Enum_Comparison_Exp = { + _eq?: Maybe; + _in?: Maybe>; + _is_null?: Maybe; + _neq?: Maybe; + _nin?: Maybe>; +}; + +/** input type for inserting data into table "alert_service_type" */ +export type Alert_Service_Type_Insert_Input = { + description?: Maybe; + name?: Maybe; +}; + +/** aggregate max on columns */ +export type Alert_Service_Type_Max_Fields = { + __typename?: 'alert_service_type_max_fields'; + description?: Maybe; + name?: Maybe; +}; + +/** aggregate min on columns */ +export type Alert_Service_Type_Min_Fields = { + __typename?: 'alert_service_type_min_fields'; + description?: Maybe; + name?: Maybe; +}; + +/** response of any mutation on the table "alert_service_type" */ +export type Alert_Service_Type_Mutation_Response = { + __typename?: 'alert_service_type_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** on_conflict condition type for table "alert_service_type" */ +export type Alert_Service_Type_On_Conflict = { + constraint: Alert_Service_Type_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "alert_service_type". */ +export type Alert_Service_Type_Order_By = { + description?: Maybe; + name?: Maybe; +}; + +/** primary key columns input for table: alert_service_type */ +export type Alert_Service_Type_Pk_Columns_Input = { + name: Scalars['String']; +}; + +/** select columns of table "alert_service_type" */ +export enum Alert_Service_Type_Select_Column { + /** column name */ + Description = 'description', + /** column name */ + Name = 'name', +} + +/** input type for updating data in table "alert_service_type" */ +export type Alert_Service_Type_Set_Input = { + description?: Maybe; + name?: Maybe; +}; + +/** Streaming cursor of the table "alert_service_type" */ +export type Alert_Service_Type_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Alert_Service_Type_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Alert_Service_Type_Stream_Cursor_Value_Input = { + description?: Maybe; + name?: Maybe; +}; + +/** update columns of table "alert_service_type" */ +export enum Alert_Service_Type_Update_Column { + /** column name */ + Description = 'description', + /** column name */ + Name = 'name', +} + +export type Alert_Service_Type_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Alert_Service_Type_Bool_Exp; +}; + +/** Alert type enum for alert configuration */ +export type Alert_Type = { + __typename?: 'alert_type'; + description: Scalars['String']; + id: Scalars['String']; + name: Scalars['String']; + template?: Maybe; +}; + +/** aggregated selection of "alert_type" */ +export type Alert_Type_Aggregate = { + __typename?: 'alert_type_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "alert_type" */ +export type Alert_Type_Aggregate_Fields = { + __typename?: 'alert_type_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "alert_type" */ +export type Alert_Type_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** Boolean expression to filter rows from the table "alert_type". All fields are combined with a logical 'AND'. */ +export type Alert_Type_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + description?: Maybe; + id?: Maybe; + name?: Maybe; + template?: Maybe; +}; + +/** unique or primary key constraints on table "alert_type" */ +export enum Alert_Type_Constraint { + /** unique or primary key constraint on columns "id" */ + AlertTypePkey = 'alert_type_pkey', +} + +/** input type for inserting data into table "alert_type" */ +export type Alert_Type_Insert_Input = { + description?: Maybe; + id?: Maybe; + name?: Maybe; + template?: Maybe; +}; + +/** aggregate max on columns */ +export type Alert_Type_Max_Fields = { + __typename?: 'alert_type_max_fields'; + description?: Maybe; + id?: Maybe; + name?: Maybe; + template?: Maybe; +}; + +/** aggregate min on columns */ +export type Alert_Type_Min_Fields = { + __typename?: 'alert_type_min_fields'; + description?: Maybe; + id?: Maybe; + name?: Maybe; + template?: Maybe; +}; + +/** response of any mutation on the table "alert_type" */ +export type Alert_Type_Mutation_Response = { + __typename?: 'alert_type_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** input type for inserting object relation for remote table "alert_type" */ +export type Alert_Type_Obj_Rel_Insert_Input = { + data: Alert_Type_Insert_Input; + /** upsert condition */ + on_conflict?: Maybe; +}; + +/** on_conflict condition type for table "alert_type" */ +export type Alert_Type_On_Conflict = { + constraint: Alert_Type_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "alert_type". */ +export type Alert_Type_Order_By = { + description?: Maybe; + id?: Maybe; + name?: Maybe; + template?: Maybe; +}; + +/** primary key columns input for table: alert_type */ +export type Alert_Type_Pk_Columns_Input = { + id: Scalars['String']; +}; + +/** select columns of table "alert_type" */ +export enum Alert_Type_Select_Column { + /** column name */ + Description = 'description', + /** column name */ + Id = 'id', + /** column name */ + Name = 'name', + /** column name */ + Template = 'template', +} + +/** input type for updating data in table "alert_type" */ +export type Alert_Type_Set_Input = { + description?: Maybe; + id?: Maybe; + name?: Maybe; + template?: Maybe; +}; + +/** Streaming cursor of the table "alert_type" */ +export type Alert_Type_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Alert_Type_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Alert_Type_Stream_Cursor_Value_Input = { + description?: Maybe; + id?: Maybe; + name?: Maybe; + template?: Maybe; +}; + +/** update columns of table "alert_type" */ +export enum Alert_Type_Update_Column { + /** column name */ + Description = 'description', + /** column name */ + Id = 'id', + /** column name */ + Name = 'name', + /** column name */ + Template = 'template', +} + +export type Alert_Type_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Alert_Type_Bool_Exp; +}; + export type AllowedProjectResponse = { __typename?: 'AllowedProjectResponse'; id: Scalars['uuid']; @@ -2328,6 +3428,149 @@ export type Cloud_Pk_Columns_Input = { name: Scalars['String']; }; +/** columns and relationships of "cloud_regions_by_plan" */ +export type Cloud_Regions_By_Plan = { + __typename?: 'cloud_regions_by_plan'; + cloud?: Maybe; + infra_status?: Maybe; + input_variables?: Maybe; + is_active?: Maybe; + metrics_fqdn?: Maybe; + name?: Maybe; + nat_ip?: Maybe; + output_variables?: Maybe; + plan_name?: Maybe; + /** An object relationship */ + region?: Maybe; +}; + +/** columns and relationships of "cloud_regions_by_plan" */ +export type Cloud_Regions_By_PlanInput_VariablesArgs = { + path?: Maybe; +}; + +/** columns and relationships of "cloud_regions_by_plan" */ +export type Cloud_Regions_By_PlanOutput_VariablesArgs = { + path?: Maybe; +}; + +/** aggregated selection of "cloud_regions_by_plan" */ +export type Cloud_Regions_By_Plan_Aggregate = { + __typename?: 'cloud_regions_by_plan_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "cloud_regions_by_plan" */ +export type Cloud_Regions_By_Plan_Aggregate_Fields = { + __typename?: 'cloud_regions_by_plan_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "cloud_regions_by_plan" */ +export type Cloud_Regions_By_Plan_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** Boolean expression to filter rows from the table "cloud_regions_by_plan". All fields are combined with a logical 'AND'. */ +export type Cloud_Regions_By_Plan_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + cloud?: Maybe; + infra_status?: Maybe; + input_variables?: Maybe; + is_active?: Maybe; + metrics_fqdn?: Maybe; + name?: Maybe; + nat_ip?: Maybe; + output_variables?: Maybe; + plan_name?: Maybe; + region?: Maybe; +}; + +/** aggregate max on columns */ +export type Cloud_Regions_By_Plan_Max_Fields = { + __typename?: 'cloud_regions_by_plan_max_fields'; + cloud?: Maybe; + infra_status?: Maybe; + metrics_fqdn?: Maybe; + name?: Maybe; + nat_ip?: Maybe; + plan_name?: Maybe; +}; + +/** aggregate min on columns */ +export type Cloud_Regions_By_Plan_Min_Fields = { + __typename?: 'cloud_regions_by_plan_min_fields'; + cloud?: Maybe; + infra_status?: Maybe; + metrics_fqdn?: Maybe; + name?: Maybe; + nat_ip?: Maybe; + plan_name?: Maybe; +}; + +/** Ordering options when selecting data from "cloud_regions_by_plan". */ +export type Cloud_Regions_By_Plan_Order_By = { + cloud?: Maybe; + infra_status?: Maybe; + input_variables?: Maybe; + is_active?: Maybe; + metrics_fqdn?: Maybe; + name?: Maybe; + nat_ip?: Maybe; + output_variables?: Maybe; + plan_name?: Maybe; + region?: Maybe; +}; + +/** select columns of table "cloud_regions_by_plan" */ +export enum Cloud_Regions_By_Plan_Select_Column { + /** column name */ + Cloud = 'cloud', + /** column name */ + InfraStatus = 'infra_status', + /** column name */ + InputVariables = 'input_variables', + /** column name */ + IsActive = 'is_active', + /** column name */ + MetricsFqdn = 'metrics_fqdn', + /** column name */ + Name = 'name', + /** column name */ + NatIp = 'nat_ip', + /** column name */ + OutputVariables = 'output_variables', + /** column name */ + PlanName = 'plan_name', +} + +/** Streaming cursor of the table "cloud_regions_by_plan" */ +export type Cloud_Regions_By_Plan_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Cloud_Regions_By_Plan_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Cloud_Regions_By_Plan_Stream_Cursor_Value_Input = { + cloud?: Maybe; + infra_status?: Maybe; + input_variables?: Maybe; + is_active?: Maybe; + metrics_fqdn?: Maybe; + name?: Maybe; + nat_ip?: Maybe; + output_variables?: Maybe; + plan_name?: Maybe; +}; + /** select columns of table "cloud" */ export enum Cloud_Select_Column { /** column name */ @@ -3131,6 +4374,803 @@ export type Config_Updates = { where: Config_Bool_Exp; }; +/** This table contains configuration of custom connectors added by users. */ +export type Connector_Config = { + __typename?: 'connector_config'; + created_at: Scalars['timestamptz']; + created_by: Scalars['uuid']; + deployment_url?: Maybe; + id: Scalars['uuid']; + is_deleted: Scalars['Boolean']; + name: Scalars['String']; + project_id: Scalars['uuid']; + source_url: Scalars['String']; + updated_at: Scalars['timestamptz']; +}; + +/** aggregated selection of "connector_config" */ +export type Connector_Config_Aggregate = { + __typename?: 'connector_config_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "connector_config" */ +export type Connector_Config_Aggregate_Fields = { + __typename?: 'connector_config_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "connector_config" */ +export type Connector_Config_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** Boolean expression to filter rows from the table "connector_config". All fields are combined with a logical 'AND'. */ +export type Connector_Config_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + created_at?: Maybe; + created_by?: Maybe; + deployment_url?: Maybe; + id?: Maybe; + is_deleted?: Maybe; + name?: Maybe; + project_id?: Maybe; + source_url?: Maybe; + updated_at?: Maybe; +}; + +/** unique or primary key constraints on table "connector_config" */ +export enum Connector_Config_Constraint { + /** unique or primary key constraint on columns "name" */ + ConnectorConfigNameKey = 'connector_config_name_key', + /** unique or primary key constraint on columns "id" */ + ConnectorConfigPkey = 'connector_config_pkey', +} + +/** input type for inserting data into table "connector_config" */ +export type Connector_Config_Insert_Input = { + created_at?: Maybe; + created_by?: Maybe; + deployment_url?: Maybe; + id?: Maybe; + is_deleted?: Maybe; + name?: Maybe; + project_id?: Maybe; + source_url?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate max on columns */ +export type Connector_Config_Max_Fields = { + __typename?: 'connector_config_max_fields'; + created_at?: Maybe; + created_by?: Maybe; + deployment_url?: Maybe; + id?: Maybe; + name?: Maybe; + project_id?: Maybe; + source_url?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate min on columns */ +export type Connector_Config_Min_Fields = { + __typename?: 'connector_config_min_fields'; + created_at?: Maybe; + created_by?: Maybe; + deployment_url?: Maybe; + id?: Maybe; + name?: Maybe; + project_id?: Maybe; + source_url?: Maybe; + updated_at?: Maybe; +}; + +/** response of any mutation on the table "connector_config" */ +export type Connector_Config_Mutation_Response = { + __typename?: 'connector_config_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** on_conflict condition type for table "connector_config" */ +export type Connector_Config_On_Conflict = { + constraint: Connector_Config_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "connector_config". */ +export type Connector_Config_Order_By = { + created_at?: Maybe; + created_by?: Maybe; + deployment_url?: Maybe; + id?: Maybe; + is_deleted?: Maybe; + name?: Maybe; + project_id?: Maybe; + source_url?: Maybe; + updated_at?: Maybe; +}; + +/** primary key columns input for table: connector_config */ +export type Connector_Config_Pk_Columns_Input = { + id: Scalars['uuid']; +}; + +/** select columns of table "connector_config" */ +export enum Connector_Config_Select_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + CreatedBy = 'created_by', + /** column name */ + DeploymentUrl = 'deployment_url', + /** column name */ + Id = 'id', + /** column name */ + IsDeleted = 'is_deleted', + /** column name */ + Name = 'name', + /** column name */ + ProjectId = 'project_id', + /** column name */ + SourceUrl = 'source_url', + /** column name */ + UpdatedAt = 'updated_at', +} + +/** input type for updating data in table "connector_config" */ +export type Connector_Config_Set_Input = { + created_at?: Maybe; + created_by?: Maybe; + deployment_url?: Maybe; + id?: Maybe; + is_deleted?: Maybe; + name?: Maybe; + project_id?: Maybe; + source_url?: Maybe; + updated_at?: Maybe; +}; + +/** Streaming cursor of the table "connector_config" */ +export type Connector_Config_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Connector_Config_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Connector_Config_Stream_Cursor_Value_Input = { + created_at?: Maybe; + created_by?: Maybe; + deployment_url?: Maybe; + id?: Maybe; + is_deleted?: Maybe; + name?: Maybe; + project_id?: Maybe; + source_url?: Maybe; + updated_at?: Maybe; +}; + +/** update columns of table "connector_config" */ +export enum Connector_Config_Update_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + CreatedBy = 'created_by', + /** column name */ + DeploymentUrl = 'deployment_url', + /** column name */ + Id = 'id', + /** column name */ + IsDeleted = 'is_deleted', + /** column name */ + Name = 'name', + /** column name */ + ProjectId = 'project_id', + /** column name */ + SourceUrl = 'source_url', + /** column name */ + UpdatedAt = 'updated_at', +} + +export type Connector_Config_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Connector_Config_Bool_Exp; +}; + +/** This table contains configuration of custom connectors deployed by users. */ +export type Connector_Connector_Deployment = { + __typename?: 'connector_connector_deployment'; + build_logs_url?: Maybe; + cloud_run_url?: Maybe; + config_file?: Maybe; + created_at: Scalars['connector_timestamptz']; + created_by: Scalars['connector_uuid']; + error?: Maybe; + gcs_url?: Maybe; + id: Scalars['connector_uuid']; + image_url?: Maybe; + name: Scalars['String']; + source_url: Scalars['String']; + status: Scalars['connector_deployment_status']; + updated_at: Scalars['connector_timestamptz']; + user_id: Scalars['connector_uuid']; +}; + +/** aggregated selection of "connector_deployment" */ +export type Connector_Connector_Deployment_Aggregate = { + __typename?: 'connector_connector_deployment_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "connector_deployment" */ +export type Connector_Connector_Deployment_Aggregate_Fields = { + __typename?: 'connector_connector_deployment_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "connector_deployment" */ +export type Connector_Connector_Deployment_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** Boolean expression to filter rows from the table "connector_deployment". All fields are combined with a logical 'AND'. */ +export type Connector_Connector_Deployment_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + build_logs_url?: Maybe; + cloud_run_url?: Maybe; + config_file?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + error?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + name?: Maybe; + source_url?: Maybe; + status?: Maybe; + updated_at?: Maybe; + user_id?: Maybe; +}; + +/** unique or primary key constraints on table "connector_deployment" */ +export enum Connector_Connector_Deployment_Constraint { + /** unique or primary key constraint on columns "id" */ + ConnectorDeploymentPkey = 'connector_deployment_pkey', + /** unique or primary key constraint on columns "user_id", "name" */ + UniqueNameWithinUser = 'unique_name_within_user', +} + +/** input type for inserting data into table "connector_deployment" */ +export type Connector_Connector_Deployment_Insert_Input = { + build_logs_url?: Maybe; + cloud_run_url?: Maybe; + config_file?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + error?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + name?: Maybe; + source_url?: Maybe; + status?: Maybe; + updated_at?: Maybe; + user_id?: Maybe; +}; + +/** aggregate max on columns */ +export type Connector_Connector_Deployment_Max_Fields = { + __typename?: 'connector_connector_deployment_max_fields'; + build_logs_url?: Maybe; + cloud_run_url?: Maybe; + config_file?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + error?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + name?: Maybe; + source_url?: Maybe; + status?: Maybe; + updated_at?: Maybe; + user_id?: Maybe; +}; + +/** aggregate min on columns */ +export type Connector_Connector_Deployment_Min_Fields = { + __typename?: 'connector_connector_deployment_min_fields'; + build_logs_url?: Maybe; + cloud_run_url?: Maybe; + config_file?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + error?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + name?: Maybe; + source_url?: Maybe; + status?: Maybe; + updated_at?: Maybe; + user_id?: Maybe; +}; + +/** response of any mutation on the table "connector_deployment" */ +export type Connector_Connector_Deployment_Mutation_Response = { + __typename?: 'connector_connector_deployment_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** on_conflict condition type for table "connector_deployment" */ +export type Connector_Connector_Deployment_On_Conflict = { + constraint: Connector_Connector_Deployment_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "connector_deployment". */ +export type Connector_Connector_Deployment_Order_By = { + build_logs_url?: Maybe; + cloud_run_url?: Maybe; + config_file?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + error?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + name?: Maybe; + source_url?: Maybe; + status?: Maybe; + updated_at?: Maybe; + user_id?: Maybe; +}; + +/** primary key columns input for table: connector_deployment */ +export type Connector_Connector_Deployment_Pk_Columns_Input = { + id: Scalars['connector_uuid']; +}; + +/** select columns of table "connector_deployment" */ +export enum Connector_Connector_Deployment_Select_Column { + /** column name */ + BuildLogsUrl = 'build_logs_url', + /** column name */ + CloudRunUrl = 'cloud_run_url', + /** column name */ + ConfigFile = 'config_file', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + CreatedBy = 'created_by', + /** column name */ + Error = 'error', + /** column name */ + GcsUrl = 'gcs_url', + /** column name */ + Id = 'id', + /** column name */ + ImageUrl = 'image_url', + /** column name */ + Name = 'name', + /** column name */ + SourceUrl = 'source_url', + /** column name */ + Status = 'status', + /** column name */ + UpdatedAt = 'updated_at', + /** column name */ + UserId = 'user_id', +} + +/** input type for updating data in table "connector_deployment" */ +export type Connector_Connector_Deployment_Set_Input = { + build_logs_url?: Maybe; + cloud_run_url?: Maybe; + config_file?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + error?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + name?: Maybe; + source_url?: Maybe; + status?: Maybe; + updated_at?: Maybe; + user_id?: Maybe; +}; + +/** Streaming cursor of the table "connector_deployment" */ +export type Connector_Connector_Deployment_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Connector_Connector_Deployment_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Connector_Connector_Deployment_Stream_Cursor_Value_Input = { + build_logs_url?: Maybe; + cloud_run_url?: Maybe; + config_file?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + error?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + name?: Maybe; + source_url?: Maybe; + status?: Maybe; + updated_at?: Maybe; + user_id?: Maybe; +}; + +/** update columns of table "connector_deployment" */ +export enum Connector_Connector_Deployment_Update_Column { + /** column name */ + BuildLogsUrl = 'build_logs_url', + /** column name */ + CloudRunUrl = 'cloud_run_url', + /** column name */ + ConfigFile = 'config_file', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + CreatedBy = 'created_by', + /** column name */ + Error = 'error', + /** column name */ + GcsUrl = 'gcs_url', + /** column name */ + Id = 'id', + /** column name */ + ImageUrl = 'image_url', + /** column name */ + Name = 'name', + /** column name */ + SourceUrl = 'source_url', + /** column name */ + Status = 'status', + /** column name */ + UpdatedAt = 'updated_at', + /** column name */ + UserId = 'user_id', +} + +export type Connector_Connector_Deployment_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Connector_Connector_Deployment_Bool_Exp; +}; + +/** ordering argument of a cursor */ +export enum Connector_Cursor_Ordering { + /** ascending ordering of the cursor */ + Asc = 'ASC', + /** descending ordering of the cursor */ + Desc = 'DESC', +} + +/** Boolean expression to compare columns of type "deployment_status". All fields are combined with logical 'AND'. */ +export type Connector_Deployment_Status_Comparison_Exp = { + _eq?: Maybe; + _gt?: Maybe; + _gte?: Maybe; + _in?: Maybe>; + _is_null?: Maybe; + _lt?: Maybe; + _lte?: Maybe; + _neq?: Maybe; + _nin?: Maybe>; +}; + +/** Each entry in this table corresponds to a deployment made for a custom connector configure by the user. */ +export type Connector_Deployments = { + __typename?: 'connector_deployments'; + cloud_run_url?: Maybe; + connector_id: Scalars['uuid']; + created_at: Scalars['timestamptz']; + created_by: Scalars['uuid']; + gcs_url?: Maybe; + id: Scalars['uuid']; + image_url?: Maybe; + updated_at: Scalars['timestamptz']; +}; + +/** aggregated selection of "connector_deployments" */ +export type Connector_Deployments_Aggregate = { + __typename?: 'connector_deployments_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "connector_deployments" */ +export type Connector_Deployments_Aggregate_Fields = { + __typename?: 'connector_deployments_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "connector_deployments" */ +export type Connector_Deployments_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** Boolean expression to filter rows from the table "connector_deployments". All fields are combined with a logical 'AND'. */ +export type Connector_Deployments_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + cloud_run_url?: Maybe; + connector_id?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + updated_at?: Maybe; +}; + +/** unique or primary key constraints on table "connector_deployments" */ +export enum Connector_Deployments_Constraint { + /** unique or primary key constraint on columns "id" */ + ConnectorDeploymentsPkey = 'connector_deployments_pkey', +} + +/** input type for inserting data into table "connector_deployments" */ +export type Connector_Deployments_Insert_Input = { + cloud_run_url?: Maybe; + connector_id?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate max on columns */ +export type Connector_Deployments_Max_Fields = { + __typename?: 'connector_deployments_max_fields'; + cloud_run_url?: Maybe; + connector_id?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate min on columns */ +export type Connector_Deployments_Min_Fields = { + __typename?: 'connector_deployments_min_fields'; + cloud_run_url?: Maybe; + connector_id?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + updated_at?: Maybe; +}; + +/** response of any mutation on the table "connector_deployments" */ +export type Connector_Deployments_Mutation_Response = { + __typename?: 'connector_deployments_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** on_conflict condition type for table "connector_deployments" */ +export type Connector_Deployments_On_Conflict = { + constraint: Connector_Deployments_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "connector_deployments". */ +export type Connector_Deployments_Order_By = { + cloud_run_url?: Maybe; + connector_id?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + updated_at?: Maybe; +}; + +/** primary key columns input for table: connector_deployments */ +export type Connector_Deployments_Pk_Columns_Input = { + id: Scalars['uuid']; +}; + +/** select columns of table "connector_deployments" */ +export enum Connector_Deployments_Select_Column { + /** column name */ + CloudRunUrl = 'cloud_run_url', + /** column name */ + ConnectorId = 'connector_id', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + CreatedBy = 'created_by', + /** column name */ + GcsUrl = 'gcs_url', + /** column name */ + Id = 'id', + /** column name */ + ImageUrl = 'image_url', + /** column name */ + UpdatedAt = 'updated_at', +} + +/** input type for updating data in table "connector_deployments" */ +export type Connector_Deployments_Set_Input = { + cloud_run_url?: Maybe; + connector_id?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + updated_at?: Maybe; +}; + +/** Streaming cursor of the table "connector_deployments" */ +export type Connector_Deployments_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Connector_Deployments_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Connector_Deployments_Stream_Cursor_Value_Input = { + cloud_run_url?: Maybe; + connector_id?: Maybe; + created_at?: Maybe; + created_by?: Maybe; + gcs_url?: Maybe; + id?: Maybe; + image_url?: Maybe; + updated_at?: Maybe; +}; + +/** update columns of table "connector_deployments" */ +export enum Connector_Deployments_Update_Column { + /** column name */ + CloudRunUrl = 'cloud_run_url', + /** column name */ + ConnectorId = 'connector_id', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + CreatedBy = 'created_by', + /** column name */ + GcsUrl = 'gcs_url', + /** column name */ + Id = 'id', + /** column name */ + ImageUrl = 'image_url', + /** column name */ + UpdatedAt = 'updated_at', +} + +export type Connector_Deployments_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Connector_Deployments_Bool_Exp; +}; + +/** column ordering options */ +export enum Connector_Order_By { + /** in ascending order, nulls last */ + Asc = 'asc', + /** in ascending order, nulls first */ + AscNullsFirst = 'asc_nulls_first', + /** in ascending order, nulls last */ + AscNullsLast = 'asc_nulls_last', + /** in descending order, nulls first */ + Desc = 'desc', + /** in descending order, nulls first */ + DescNullsFirst = 'desc_nulls_first', + /** in descending order, nulls last */ + DescNullsLast = 'desc_nulls_last', +} + +/** Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'. */ +export type Connector_String_Comparison_Exp = { + _eq?: Maybe; + _gt?: Maybe; + _gte?: Maybe; + /** does the column match the given case-insensitive pattern */ + _ilike?: Maybe; + _in?: Maybe>; + /** does the column match the given POSIX regular expression, case insensitive */ + _iregex?: Maybe; + _is_null?: Maybe; + /** does the column match the given pattern */ + _like?: Maybe; + _lt?: Maybe; + _lte?: Maybe; + _neq?: Maybe; + /** does the column NOT match the given case-insensitive pattern */ + _nilike?: Maybe; + _nin?: Maybe>; + /** does the column NOT match the given POSIX regular expression, case insensitive */ + _niregex?: Maybe; + /** does the column NOT match the given pattern */ + _nlike?: Maybe; + /** does the column NOT match the given POSIX regular expression, case sensitive */ + _nregex?: Maybe; + /** does the column NOT match the given SQL regular expression */ + _nsimilar?: Maybe; + /** does the column match the given POSIX regular expression, case sensitive */ + _regex?: Maybe; + /** does the column match the given SQL regular expression */ + _similar?: Maybe; +}; + +/** Boolean expression to compare columns of type "timestamptz". All fields are combined with logical 'AND'. */ +export type Connector_Timestamptz_Comparison_Exp = { + _eq?: Maybe; + _gt?: Maybe; + _gte?: Maybe; + _in?: Maybe>; + _is_null?: Maybe; + _lt?: Maybe; + _lte?: Maybe; + _neq?: Maybe; + _nin?: Maybe>; +}; + +/** Boolean expression to compare columns of type "uuid". All fields are combined with logical 'AND'. */ +export type Connector_Uuid_Comparison_Exp = { + _eq?: Maybe; + _gt?: Maybe; + _gte?: Maybe; + _in?: Maybe>; + _is_null?: Maybe; + _lt?: Maybe; + _lte?: Maybe; + _neq?: Maybe; + _nin?: Maybe>; +}; + export type ConvertPlanResponse = { __typename?: 'ConvertPlanResponse'; status: Scalars['String']; @@ -4564,6 +6604,11 @@ export type CreateTenantResponse = { tenant?: Maybe; }; +export type CreateTunnelOutput = { + __typename?: 'CreateTunnelOutput'; + tunnel?: Maybe; +}; + /** ordering argument of a cursor */ export enum Cursor_Ordering { /** ascending ordering of the cursor */ @@ -6011,6 +8056,7 @@ export enum Data_Connector_Type_Constraint { } export enum Data_Connector_Type_Enum { + MongodbConnector = 'mongodb_connector', SuperConnector = 'super_connector', } @@ -6780,7 +8826,8 @@ export type Ddn_Build = { build_sync_statuses: Array; /** An aggregate relationship */ build_sync_statuses_aggregate: Ddn_Build_Sync_Status_Aggregate; - created_at: Scalars['timestamp']; + created_at: Scalars['timestamptz']; + description?: Maybe; /** An array relationship */ environments: Array; /** An aggregate relationship */ @@ -6790,10 +8837,13 @@ export type Ddn_Build = { /** this will be later moved to a blob storage */ metadata_binary?: Maybe; metadata_raw: Scalars['String']; + ndc_configs: Scalars['jsonb']; + parent_span_id?: Maybe; /** An object relationship */ project: Ddn_Projects; project_id: Scalars['uuid']; - updated_at: Scalars['timestamp']; + trace_id?: Maybe; + updated_at: Scalars['timestamptz']; version: Scalars['String']; }; @@ -6833,6 +8883,11 @@ export type Ddn_BuildEnvironments_AggregateArgs = { where?: Maybe; }; +/** columns and relationships of "ddn.build" */ +export type Ddn_BuildNdc_ConfigsArgs = { + path?: Maybe; +}; + /** aggregated selection of "ddn.build" */ export type Ddn_Build_Aggregate = { __typename?: 'ddn_build_aggregate'; @@ -6872,6 +8927,11 @@ export type Ddn_Build_Aggregate_Order_By = { min?: Maybe; }; +/** append existing jsonb value of filtered columns with new jsonb value */ +export type Ddn_Build_Append_Input = { + ndc_configs?: Maybe; +}; + /** input type for inserting array relation for remote table "ddn.build" */ export type Ddn_Build_Arr_Rel_Insert_Input = { data: Array; @@ -6886,16 +8946,20 @@ export type Ddn_Build_Bool_Exp = { _or?: Maybe>; build_sync_statuses?: Maybe; build_sync_statuses_aggregate?: Maybe; - created_at?: Maybe; + created_at?: Maybe; + description?: Maybe; environments?: Maybe; environments_aggregate?: Maybe; fqdn?: Maybe; id?: Maybe; metadata_binary?: Maybe; metadata_raw?: Maybe; + ndc_configs?: Maybe; + parent_span_id?: Maybe; project?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + trace_id?: Maybe; + updated_at?: Maybe; version?: Maybe; }; @@ -6905,43 +8969,73 @@ export enum Ddn_Build_Constraint { BuildFqdnKey = 'build_fqdn_key', /** unique or primary key constraint on columns "id" */ BuildPkey = 'build_pkey', + /** unique or primary key constraint on columns "project_id", "id" */ + UniqueProjectAndBuild = 'unique_project_and_build', } +/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */ +export type Ddn_Build_Delete_At_Path_Input = { + ndc_configs?: Maybe>; +}; + +/** + * delete the array element with specified index (negative integers count from the + * end). throws an error if top level container is not an array + */ +export type Ddn_Build_Delete_Elem_Input = { + ndc_configs?: Maybe; +}; + +/** delete key/value pair or string element. key/value pairs are matched based on their key value */ +export type Ddn_Build_Delete_Key_Input = { + ndc_configs?: Maybe; +}; + /** input type for inserting data into table "ddn.build" */ export type Ddn_Build_Insert_Input = { build_sync_statuses?: Maybe; - created_at?: Maybe; + created_at?: Maybe; + description?: Maybe; environments?: Maybe; fqdn?: Maybe; id?: Maybe; /** this will be later moved to a blob storage */ metadata_binary?: Maybe; metadata_raw?: Maybe; + ndc_configs?: Maybe; + parent_span_id?: Maybe; project?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + trace_id?: Maybe; + updated_at?: Maybe; version?: Maybe; }; /** aggregate max on columns */ export type Ddn_Build_Max_Fields = { __typename?: 'ddn_build_max_fields'; - created_at?: Maybe; + created_at?: Maybe; + description?: Maybe; fqdn?: Maybe; id?: Maybe; metadata_raw?: Maybe; + parent_span_id?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + trace_id?: Maybe; + updated_at?: Maybe; version?: Maybe; }; /** order by max() on columns of table "ddn.build" */ export type Ddn_Build_Max_Order_By = { created_at?: Maybe; + description?: Maybe; fqdn?: Maybe; id?: Maybe; metadata_raw?: Maybe; + parent_span_id?: Maybe; project_id?: Maybe; + trace_id?: Maybe; updated_at?: Maybe; version?: Maybe; }; @@ -6949,22 +9043,28 @@ export type Ddn_Build_Max_Order_By = { /** aggregate min on columns */ export type Ddn_Build_Min_Fields = { __typename?: 'ddn_build_min_fields'; - created_at?: Maybe; + created_at?: Maybe; + description?: Maybe; fqdn?: Maybe; id?: Maybe; metadata_raw?: Maybe; + parent_span_id?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + trace_id?: Maybe; + updated_at?: Maybe; version?: Maybe; }; /** order by min() on columns of table "ddn.build" */ export type Ddn_Build_Min_Order_By = { created_at?: Maybe; + description?: Maybe; fqdn?: Maybe; id?: Maybe; metadata_raw?: Maybe; + parent_span_id?: Maybe; project_id?: Maybe; + trace_id?: Maybe; updated_at?: Maybe; version?: Maybe; }; @@ -6996,13 +9096,17 @@ export type Ddn_Build_On_Conflict = { export type Ddn_Build_Order_By = { build_sync_statuses_aggregate?: Maybe; created_at?: Maybe; + description?: Maybe; environments_aggregate?: Maybe; fqdn?: Maybe; id?: Maybe; metadata_binary?: Maybe; metadata_raw?: Maybe; + ndc_configs?: Maybe; + parent_span_id?: Maybe; project?: Maybe; project_id?: Maybe; + trace_id?: Maybe; updated_at?: Maybe; version?: Maybe; }; @@ -7012,11 +9116,18 @@ export type Ddn_Build_Pk_Columns_Input = { id: Scalars['uuid']; }; +/** prepend existing jsonb value of filtered columns with new jsonb value */ +export type Ddn_Build_Prepend_Input = { + ndc_configs?: Maybe; +}; + /** select columns of table "ddn.build" */ export enum Ddn_Build_Select_Column { /** column name */ CreatedAt = 'created_at', /** column name */ + Description = 'description', + /** column name */ Fqdn = 'fqdn', /** column name */ Id = 'id', @@ -7025,8 +9136,14 @@ export enum Ddn_Build_Select_Column { /** column name */ MetadataRaw = 'metadata_raw', /** column name */ + NdcConfigs = 'ndc_configs', + /** column name */ + ParentSpanId = 'parent_span_id', + /** column name */ ProjectId = 'project_id', /** column name */ + TraceId = 'trace_id', + /** column name */ UpdatedAt = 'updated_at', /** column name */ Version = 'version', @@ -7034,14 +9151,18 @@ export enum Ddn_Build_Select_Column { /** input type for updating data in table "ddn.build" */ export type Ddn_Build_Set_Input = { - created_at?: Maybe; + created_at?: Maybe; + description?: Maybe; fqdn?: Maybe; id?: Maybe; /** this will be later moved to a blob storage */ metadata_binary?: Maybe; metadata_raw?: Maybe; + ndc_configs?: Maybe; + parent_span_id?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + trace_id?: Maybe; + updated_at?: Maybe; version?: Maybe; }; @@ -7055,14 +9176,18 @@ export type Ddn_Build_Stream_Cursor_Input = { /** Initial value of the column from where the streaming should start */ export type Ddn_Build_Stream_Cursor_Value_Input = { - created_at?: Maybe; + created_at?: Maybe; + description?: Maybe; fqdn?: Maybe; id?: Maybe; /** this will be later moved to a blob storage */ metadata_binary?: Maybe; metadata_raw?: Maybe; + ndc_configs?: Maybe; + parent_span_id?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + trace_id?: Maybe; + updated_at?: Maybe; version?: Maybe; }; @@ -7074,12 +9199,13 @@ export type Ddn_Build_Sync_Status = { build_id: Scalars['uuid']; /** An object relationship */ build_sync_worker: Ddn_Build_Sync_Worker; + created_at?: Maybe; /** An object relationship */ environment?: Maybe; environment_id?: Maybe; id: Scalars['uuid']; status?: Maybe; - updated_at: Scalars['timestamp']; + updated_at: Scalars['timestamptz']; worker_id: Scalars['uuid']; }; @@ -7137,11 +9263,12 @@ export type Ddn_Build_Sync_Status_Bool_Exp = { build?: Maybe; build_id?: Maybe; build_sync_worker?: Maybe; + created_at?: Maybe; environment?: Maybe; environment_id?: Maybe; id?: Maybe; status?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; worker_id?: Maybe; }; @@ -7158,11 +9285,12 @@ export type Ddn_Build_Sync_Status_Insert_Input = { build?: Maybe; build_id?: Maybe; build_sync_worker?: Maybe; + created_at?: Maybe; environment?: Maybe; environment_id?: Maybe; id?: Maybe; status?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; worker_id?: Maybe; }; @@ -7170,16 +9298,18 @@ export type Ddn_Build_Sync_Status_Insert_Input = { export type Ddn_Build_Sync_Status_Max_Fields = { __typename?: 'ddn_build_sync_status_max_fields'; build_id?: Maybe; + created_at?: Maybe; environment_id?: Maybe; id?: Maybe; status?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; worker_id?: Maybe; }; /** order by max() on columns of table "ddn.build_sync_status" */ export type Ddn_Build_Sync_Status_Max_Order_By = { build_id?: Maybe; + created_at?: Maybe; environment_id?: Maybe; id?: Maybe; status?: Maybe; @@ -7191,16 +9321,18 @@ export type Ddn_Build_Sync_Status_Max_Order_By = { export type Ddn_Build_Sync_Status_Min_Fields = { __typename?: 'ddn_build_sync_status_min_fields'; build_id?: Maybe; + created_at?: Maybe; environment_id?: Maybe; id?: Maybe; status?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; worker_id?: Maybe; }; /** order by min() on columns of table "ddn.build_sync_status" */ export type Ddn_Build_Sync_Status_Min_Order_By = { build_id?: Maybe; + created_at?: Maybe; environment_id?: Maybe; id?: Maybe; status?: Maybe; @@ -7229,6 +9361,7 @@ export type Ddn_Build_Sync_Status_Order_By = { build?: Maybe; build_id?: Maybe; build_sync_worker?: Maybe; + created_at?: Maybe; environment?: Maybe; environment_id?: Maybe; id?: Maybe; @@ -7247,6 +9380,8 @@ export enum Ddn_Build_Sync_Status_Select_Column { /** column name */ BuildId = 'build_id', /** column name */ + CreatedAt = 'created_at', + /** column name */ EnvironmentId = 'environment_id', /** column name */ Id = 'id', @@ -7261,10 +9396,11 @@ export enum Ddn_Build_Sync_Status_Select_Column { /** input type for updating data in table "ddn.build_sync_status" */ export type Ddn_Build_Sync_Status_Set_Input = { build_id?: Maybe; + created_at?: Maybe; environment_id?: Maybe; id?: Maybe; status?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; worker_id?: Maybe; }; @@ -7279,10 +9415,11 @@ export type Ddn_Build_Sync_Status_Stream_Cursor_Input = { /** Initial value of the column from where the streaming should start */ export type Ddn_Build_Sync_Status_Stream_Cursor_Value_Input = { build_id?: Maybe; + created_at?: Maybe; environment_id?: Maybe; id?: Maybe; status?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; worker_id?: Maybe; }; @@ -7291,6 +9428,8 @@ export enum Ddn_Build_Sync_Status_Update_Column { /** column name */ BuildId = 'build_id', /** column name */ + CreatedAt = 'created_at', + /** column name */ EnvironmentId = 'environment_id', /** column name */ Id = 'id', @@ -7317,11 +9456,13 @@ export type Ddn_Build_Sync_Worker = { /** An aggregate relationship */ build_sync_statuses_aggregate: Ddn_Build_Sync_Status_Aggregate; cloud?: Maybe; + created_at?: Maybe; id: Scalars['uuid']; is_active: Scalars['Boolean']; region?: Maybe; /** An object relationship */ regionByCloudRegion?: Maybe; + updated_at?: Maybe; }; /** columns and relationships of "ddn.build_sync_worker" */ @@ -7371,10 +9512,12 @@ export type Ddn_Build_Sync_Worker_Bool_Exp = { build_sync_statuses?: Maybe; build_sync_statuses_aggregate?: Maybe; cloud?: Maybe; + created_at?: Maybe; id?: Maybe; is_active?: Maybe; region?: Maybe; regionByCloudRegion?: Maybe; + updated_at?: Maybe; }; /** unique or primary key constraints on table "ddn.build_sync_worker" */ @@ -7387,26 +9530,32 @@ export enum Ddn_Build_Sync_Worker_Constraint { export type Ddn_Build_Sync_Worker_Insert_Input = { build_sync_statuses?: Maybe; cloud?: Maybe; + created_at?: Maybe; id?: Maybe; is_active?: Maybe; region?: Maybe; regionByCloudRegion?: Maybe; + updated_at?: Maybe; }; /** aggregate max on columns */ export type Ddn_Build_Sync_Worker_Max_Fields = { __typename?: 'ddn_build_sync_worker_max_fields'; cloud?: Maybe; + created_at?: Maybe; id?: Maybe; region?: Maybe; + updated_at?: Maybe; }; /** aggregate min on columns */ export type Ddn_Build_Sync_Worker_Min_Fields = { __typename?: 'ddn_build_sync_worker_min_fields'; cloud?: Maybe; + created_at?: Maybe; id?: Maybe; region?: Maybe; + updated_at?: Maybe; }; /** response of any mutation on the table "ddn.build_sync_worker" */ @@ -7436,10 +9585,12 @@ export type Ddn_Build_Sync_Worker_On_Conflict = { export type Ddn_Build_Sync_Worker_Order_By = { build_sync_statuses_aggregate?: Maybe; cloud?: Maybe; + created_at?: Maybe; id?: Maybe; is_active?: Maybe; region?: Maybe; regionByCloudRegion?: Maybe; + updated_at?: Maybe; }; /** primary key columns input for table: ddn.build_sync_worker */ @@ -7452,19 +9603,25 @@ export enum Ddn_Build_Sync_Worker_Select_Column { /** column name */ Cloud = 'cloud', /** column name */ + CreatedAt = 'created_at', + /** column name */ Id = 'id', /** column name */ IsActive = 'is_active', /** column name */ Region = 'region', + /** column name */ + UpdatedAt = 'updated_at', } /** input type for updating data in table "ddn.build_sync_worker" */ export type Ddn_Build_Sync_Worker_Set_Input = { cloud?: Maybe; + created_at?: Maybe; id?: Maybe; is_active?: Maybe; region?: Maybe; + updated_at?: Maybe; }; /** Streaming cursor of the table "ddn_build_sync_worker" */ @@ -7478,9 +9635,11 @@ export type Ddn_Build_Sync_Worker_Stream_Cursor_Input = { /** Initial value of the column from where the streaming should start */ export type Ddn_Build_Sync_Worker_Stream_Cursor_Value_Input = { cloud?: Maybe; + created_at?: Maybe; id?: Maybe; is_active?: Maybe; region?: Maybe; + updated_at?: Maybe; }; /** update columns of table "ddn.build_sync_worker" */ @@ -7488,11 +9647,15 @@ export enum Ddn_Build_Sync_Worker_Update_Column { /** column name */ Cloud = 'cloud', /** column name */ + CreatedAt = 'created_at', + /** column name */ Id = 'id', /** column name */ IsActive = 'is_active', /** column name */ Region = 'region', + /** column name */ + UpdatedAt = 'updated_at', } export type Ddn_Build_Sync_Worker_Updates = { @@ -7507,6 +9670,8 @@ export enum Ddn_Build_Update_Column { /** column name */ CreatedAt = 'created_at', /** column name */ + Description = 'description', + /** column name */ Fqdn = 'fqdn', /** column name */ Id = 'id', @@ -7515,14 +9680,33 @@ export enum Ddn_Build_Update_Column { /** column name */ MetadataRaw = 'metadata_raw', /** column name */ + NdcConfigs = 'ndc_configs', + /** column name */ + ParentSpanId = 'parent_span_id', + /** column name */ ProjectId = 'project_id', /** column name */ + TraceId = 'trace_id', + /** column name */ UpdatedAt = 'updated_at', /** column name */ Version = 'version', } export type Ddn_Build_Updates = { + /** append existing jsonb value of filtered columns with new jsonb value */ + _append?: Maybe; + /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */ + _delete_at_path?: Maybe; + /** + * delete the array element with specified index (negative integers count from + * the end). throws an error if top level container is not an array + */ + _delete_elem?: Maybe; + /** delete key/value pair or string element. key/value pairs are matched based on their key value */ + _delete_key?: Maybe; + /** prepend existing jsonb value of filtered columns with new jsonb value */ + _prepend?: Maybe; /** sets the columns of the filtered rows to the given values */ _set?: Maybe; /** filter the rows which have to be updated */ @@ -7538,7 +9722,7 @@ export type Ddn_Environment = { build_sync_statuses: Array; /** An aggregate relationship */ build_sync_statuses_aggregate: Ddn_Build_Sync_Status_Aggregate; - created_at: Scalars['timestamp']; + created_at: Scalars['timestamptz']; current_build_id?: Maybe; fqdn: Scalars['String']; id: Scalars['uuid']; @@ -7546,7 +9730,7 @@ export type Ddn_Environment = { /** An object relationship */ project: Ddn_Projects; project_id: Scalars['uuid']; - updated_at: Scalars['timestamp']; + updated_at: Scalars['timestamptz']; }; /** columns and relationships of "ddn.environment" */ @@ -7621,14 +9805,14 @@ export type Ddn_Environment_Bool_Exp = { build?: Maybe; build_sync_statuses?: Maybe; build_sync_statuses_aggregate?: Maybe; - created_at?: Maybe; + created_at?: Maybe; current_build_id?: Maybe; fqdn?: Maybe; id?: Maybe; name?: Maybe; project?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** unique or primary key constraints on table "ddn.environment" */ @@ -7641,26 +9825,26 @@ export enum Ddn_Environment_Constraint { export type Ddn_Environment_Insert_Input = { build?: Maybe; build_sync_statuses?: Maybe; - created_at?: Maybe; + created_at?: Maybe; current_build_id?: Maybe; fqdn?: Maybe; id?: Maybe; name?: Maybe; project?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** aggregate max on columns */ export type Ddn_Environment_Max_Fields = { __typename?: 'ddn_environment_max_fields'; - created_at?: Maybe; + created_at?: Maybe; current_build_id?: Maybe; fqdn?: Maybe; id?: Maybe; name?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** order by max() on columns of table "ddn.environment" */ @@ -7677,13 +9861,13 @@ export type Ddn_Environment_Max_Order_By = { /** aggregate min on columns */ export type Ddn_Environment_Min_Fields = { __typename?: 'ddn_environment_min_fields'; - created_at?: Maybe; + created_at?: Maybe; current_build_id?: Maybe; fqdn?: Maybe; id?: Maybe; name?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** order by min() on columns of table "ddn.environment" */ @@ -7759,13 +9943,13 @@ export enum Ddn_Environment_Select_Column { /** input type for updating data in table "ddn.environment" */ export type Ddn_Environment_Set_Input = { - created_at?: Maybe; + created_at?: Maybe; current_build_id?: Maybe; fqdn?: Maybe; id?: Maybe; name?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** Streaming cursor of the table "ddn_environment" */ @@ -7778,13 +9962,13 @@ export type Ddn_Environment_Stream_Cursor_Input = { /** Initial value of the column from where the streaming should start */ export type Ddn_Environment_Stream_Cursor_Value_Input = { - created_at?: Maybe; + created_at?: Maybe; current_build_id?: Maybe; fqdn?: Maybe; id?: Maybe; name?: Maybe; project_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** update columns of table "ddn.environment" */ @@ -7812,6 +9996,590 @@ export type Ddn_Environment_Updates = { where: Ddn_Environment_Bool_Exp; }; +/** columns and relationships of "ddn.project_entitlement_access" */ +export type Ddn_Project_Entitlement_Access = { + __typename?: 'ddn_project_entitlement_access'; + created_at: Scalars['timestamp']; + /** An object relationship */ + entitlement: Ddn_Project_Entitlement_Catalogue; + entitlement_id: Scalars['uuid']; + id: Scalars['uuid']; + /** An object relationship */ + project: Ddn_Projects; + project_id: Scalars['uuid']; + updated_at: Scalars['timestamp']; +}; + +/** aggregated selection of "ddn.project_entitlement_access" */ +export type Ddn_Project_Entitlement_Access_Aggregate = { + __typename?: 'ddn_project_entitlement_access_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "ddn.project_entitlement_access" */ +export type Ddn_Project_Entitlement_Access_Aggregate_Fields = { + __typename?: 'ddn_project_entitlement_access_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "ddn.project_entitlement_access" */ +export type Ddn_Project_Entitlement_Access_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** + * Boolean expression to filter rows from the table + * "ddn.project_entitlement_access". All fields are combined with a logical 'AND'. + */ +export type Ddn_Project_Entitlement_Access_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + created_at?: Maybe; + entitlement?: Maybe; + entitlement_id?: Maybe; + id?: Maybe; + project?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** unique or primary key constraints on table "ddn.project_entitlement_access" */ +export enum Ddn_Project_Entitlement_Access_Constraint { + /** unique or primary key constraint on columns "id" */ + ProjectEntitlementAccessPkey = 'project_entitlement_access_pkey', +} + +/** input type for inserting data into table "ddn.project_entitlement_access" */ +export type Ddn_Project_Entitlement_Access_Insert_Input = { + created_at?: Maybe; + entitlement?: Maybe; + entitlement_id?: Maybe; + id?: Maybe; + project?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate max on columns */ +export type Ddn_Project_Entitlement_Access_Max_Fields = { + __typename?: 'ddn_project_entitlement_access_max_fields'; + created_at?: Maybe; + entitlement_id?: Maybe; + id?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate min on columns */ +export type Ddn_Project_Entitlement_Access_Min_Fields = { + __typename?: 'ddn_project_entitlement_access_min_fields'; + created_at?: Maybe; + entitlement_id?: Maybe; + id?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** response of any mutation on the table "ddn.project_entitlement_access" */ +export type Ddn_Project_Entitlement_Access_Mutation_Response = { + __typename?: 'ddn_project_entitlement_access_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** on_conflict condition type for table "ddn.project_entitlement_access" */ +export type Ddn_Project_Entitlement_Access_On_Conflict = { + constraint: Ddn_Project_Entitlement_Access_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "ddn.project_entitlement_access". */ +export type Ddn_Project_Entitlement_Access_Order_By = { + created_at?: Maybe; + entitlement?: Maybe; + entitlement_id?: Maybe; + id?: Maybe; + project?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** primary key columns input for table: ddn.project_entitlement_access */ +export type Ddn_Project_Entitlement_Access_Pk_Columns_Input = { + id: Scalars['uuid']; +}; + +/** select columns of table "ddn.project_entitlement_access" */ +export enum Ddn_Project_Entitlement_Access_Select_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + EntitlementId = 'entitlement_id', + /** column name */ + Id = 'id', + /** column name */ + ProjectId = 'project_id', + /** column name */ + UpdatedAt = 'updated_at', +} + +/** input type for updating data in table "ddn.project_entitlement_access" */ +export type Ddn_Project_Entitlement_Access_Set_Input = { + created_at?: Maybe; + entitlement_id?: Maybe; + id?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** Streaming cursor of the table "ddn_project_entitlement_access" */ +export type Ddn_Project_Entitlement_Access_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Ddn_Project_Entitlement_Access_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Ddn_Project_Entitlement_Access_Stream_Cursor_Value_Input = { + created_at?: Maybe; + entitlement_id?: Maybe; + id?: Maybe; + project_id?: Maybe; + updated_at?: Maybe; +}; + +/** update columns of table "ddn.project_entitlement_access" */ +export enum Ddn_Project_Entitlement_Access_Update_Column { + /** column name */ + CreatedAt = 'created_at', + /** column name */ + EntitlementId = 'entitlement_id', + /** column name */ + Id = 'id', + /** column name */ + ProjectId = 'project_id', + /** column name */ + UpdatedAt = 'updated_at', +} + +export type Ddn_Project_Entitlement_Access_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Ddn_Project_Entitlement_Access_Bool_Exp; +}; + +/** Stores all versions of all types of v3 project entitlements. */ +export type Ddn_Project_Entitlement_Catalogue = { + __typename?: 'ddn_project_entitlement_catalogue'; + config_is_enabled: Scalars['Boolean']; + config_limit?: Maybe; + created_at: Scalars['timestamp']; + id: Scalars['uuid']; + name: Scalars['String']; + type: Scalars['String']; + updated_at: Scalars['timestamp']; +}; + +/** aggregated selection of "ddn.project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_Aggregate = { + __typename?: 'ddn_project_entitlement_catalogue_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "ddn.project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_Aggregate_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_aggregate_fields'; + avg?: Maybe; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; + stddev?: Maybe; + stddev_pop?: Maybe; + stddev_samp?: Maybe; + sum?: Maybe; + var_pop?: Maybe; + var_samp?: Maybe; + variance?: Maybe; +}; + +/** aggregate fields of "ddn.project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** aggregate avg on columns */ +export type Ddn_Project_Entitlement_Catalogue_Avg_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_avg_fields'; + config_limit?: Maybe; +}; + +/** + * Boolean expression to filter rows from the table + * "ddn.project_entitlement_catalogue". All fields are combined with a logical 'AND'. + */ +export type Ddn_Project_Entitlement_Catalogue_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + config_is_enabled?: Maybe; + config_limit?: Maybe; + created_at?: Maybe; + id?: Maybe; + name?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** unique or primary key constraints on table "ddn.project_entitlement_catalogue" */ +export enum Ddn_Project_Entitlement_Catalogue_Constraint { + /** unique or primary key constraint on columns "name" */ + ProjectEntitlementCatalogueNameKey = 'project_entitlement_catalogue_name_key', + /** unique or primary key constraint on columns "id" */ + ProjectEntitlementCataloguePkey = 'project_entitlement_catalogue_pkey', +} + +/** input type for incrementing numeric columns in table "ddn.project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_Inc_Input = { + config_limit?: Maybe; +}; + +/** input type for inserting data into table "ddn.project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_Insert_Input = { + config_is_enabled?: Maybe; + config_limit?: Maybe; + created_at?: Maybe; + id?: Maybe; + name?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate max on columns */ +export type Ddn_Project_Entitlement_Catalogue_Max_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_max_fields'; + config_limit?: Maybe; + created_at?: Maybe; + id?: Maybe; + name?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate min on columns */ +export type Ddn_Project_Entitlement_Catalogue_Min_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_min_fields'; + config_limit?: Maybe; + created_at?: Maybe; + id?: Maybe; + name?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** response of any mutation on the table "ddn.project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_Mutation_Response = { + __typename?: 'ddn_project_entitlement_catalogue_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** input type for inserting object relation for remote table "ddn.project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_Obj_Rel_Insert_Input = { + data: Ddn_Project_Entitlement_Catalogue_Insert_Input; + /** upsert condition */ + on_conflict?: Maybe; +}; + +/** on_conflict condition type for table "ddn.project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_On_Conflict = { + constraint: Ddn_Project_Entitlement_Catalogue_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "ddn.project_entitlement_catalogue". */ +export type Ddn_Project_Entitlement_Catalogue_Order_By = { + config_is_enabled?: Maybe; + config_limit?: Maybe; + created_at?: Maybe; + id?: Maybe; + name?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** primary key columns input for table: ddn.project_entitlement_catalogue */ +export type Ddn_Project_Entitlement_Catalogue_Pk_Columns_Input = { + id: Scalars['uuid']; +}; + +/** select columns of table "ddn.project_entitlement_catalogue" */ +export enum Ddn_Project_Entitlement_Catalogue_Select_Column { + /** column name */ + ConfigIsEnabled = 'config_is_enabled', + /** column name */ + ConfigLimit = 'config_limit', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Id = 'id', + /** column name */ + Name = 'name', + /** column name */ + Type = 'type', + /** column name */ + UpdatedAt = 'updated_at', +} + +/** input type for updating data in table "ddn.project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_Set_Input = { + config_is_enabled?: Maybe; + config_limit?: Maybe; + created_at?: Maybe; + id?: Maybe; + name?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate stddev on columns */ +export type Ddn_Project_Entitlement_Catalogue_Stddev_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_stddev_fields'; + config_limit?: Maybe; +}; + +/** aggregate stddev_pop on columns */ +export type Ddn_Project_Entitlement_Catalogue_Stddev_Pop_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_stddev_pop_fields'; + config_limit?: Maybe; +}; + +/** aggregate stddev_samp on columns */ +export type Ddn_Project_Entitlement_Catalogue_Stddev_Samp_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_stddev_samp_fields'; + config_limit?: Maybe; +}; + +/** Streaming cursor of the table "ddn_project_entitlement_catalogue" */ +export type Ddn_Project_Entitlement_Catalogue_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Ddn_Project_Entitlement_Catalogue_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Ddn_Project_Entitlement_Catalogue_Stream_Cursor_Value_Input = { + config_is_enabled?: Maybe; + config_limit?: Maybe; + created_at?: Maybe; + id?: Maybe; + name?: Maybe; + type?: Maybe; + updated_at?: Maybe; +}; + +/** aggregate sum on columns */ +export type Ddn_Project_Entitlement_Catalogue_Sum_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_sum_fields'; + config_limit?: Maybe; +}; + +/** update columns of table "ddn.project_entitlement_catalogue" */ +export enum Ddn_Project_Entitlement_Catalogue_Update_Column { + /** column name */ + ConfigIsEnabled = 'config_is_enabled', + /** column name */ + ConfigLimit = 'config_limit', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Id = 'id', + /** column name */ + Name = 'name', + /** column name */ + Type = 'type', + /** column name */ + UpdatedAt = 'updated_at', +} + +export type Ddn_Project_Entitlement_Catalogue_Updates = { + /** increments the numeric columns with given value of the filtered values */ + _inc?: Maybe; + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Ddn_Project_Entitlement_Catalogue_Bool_Exp; +}; + +/** aggregate var_pop on columns */ +export type Ddn_Project_Entitlement_Catalogue_Var_Pop_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_var_pop_fields'; + config_limit?: Maybe; +}; + +/** aggregate var_samp on columns */ +export type Ddn_Project_Entitlement_Catalogue_Var_Samp_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_var_samp_fields'; + config_limit?: Maybe; +}; + +/** aggregate variance on columns */ +export type Ddn_Project_Entitlement_Catalogue_Variance_Fields = { + __typename?: 'ddn_project_entitlement_catalogue_variance_fields'; + config_limit?: Maybe; +}; + +/** Enums representing types/categories of entitlements for a Hasura v3 project */ +export type Ddn_Project_Entitlement_Types = { + __typename?: 'ddn_project_entitlement_types'; + comment: Scalars['String']; + value: Scalars['String']; +}; + +/** aggregated selection of "ddn.project_entitlement_types" */ +export type Ddn_Project_Entitlement_Types_Aggregate = { + __typename?: 'ddn_project_entitlement_types_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "ddn.project_entitlement_types" */ +export type Ddn_Project_Entitlement_Types_Aggregate_Fields = { + __typename?: 'ddn_project_entitlement_types_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "ddn.project_entitlement_types" */ +export type Ddn_Project_Entitlement_Types_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** + * Boolean expression to filter rows from the table + * "ddn.project_entitlement_types". All fields are combined with a logical 'AND'. + */ +export type Ddn_Project_Entitlement_Types_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + comment?: Maybe; + value?: Maybe; +}; + +/** unique or primary key constraints on table "ddn.project_entitlement_types" */ +export enum Ddn_Project_Entitlement_Types_Constraint { + /** unique or primary key constraint on columns "value" */ + ProjectEntitlementTypesPkey = 'project_entitlement_types_pkey', +} + +/** input type for inserting data into table "ddn.project_entitlement_types" */ +export type Ddn_Project_Entitlement_Types_Insert_Input = { + comment?: Maybe; + value?: Maybe; +}; + +/** aggregate max on columns */ +export type Ddn_Project_Entitlement_Types_Max_Fields = { + __typename?: 'ddn_project_entitlement_types_max_fields'; + comment?: Maybe; + value?: Maybe; +}; + +/** aggregate min on columns */ +export type Ddn_Project_Entitlement_Types_Min_Fields = { + __typename?: 'ddn_project_entitlement_types_min_fields'; + comment?: Maybe; + value?: Maybe; +}; + +/** response of any mutation on the table "ddn.project_entitlement_types" */ +export type Ddn_Project_Entitlement_Types_Mutation_Response = { + __typename?: 'ddn_project_entitlement_types_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** on_conflict condition type for table "ddn.project_entitlement_types" */ +export type Ddn_Project_Entitlement_Types_On_Conflict = { + constraint: Ddn_Project_Entitlement_Types_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "ddn.project_entitlement_types". */ +export type Ddn_Project_Entitlement_Types_Order_By = { + comment?: Maybe; + value?: Maybe; +}; + +/** primary key columns input for table: ddn.project_entitlement_types */ +export type Ddn_Project_Entitlement_Types_Pk_Columns_Input = { + value: Scalars['String']; +}; + +/** select columns of table "ddn.project_entitlement_types" */ +export enum Ddn_Project_Entitlement_Types_Select_Column { + /** column name */ + Comment = 'comment', + /** column name */ + Value = 'value', +} + +/** input type for updating data in table "ddn.project_entitlement_types" */ +export type Ddn_Project_Entitlement_Types_Set_Input = { + comment?: Maybe; + value?: Maybe; +}; + +/** Streaming cursor of the table "ddn_project_entitlement_types" */ +export type Ddn_Project_Entitlement_Types_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Ddn_Project_Entitlement_Types_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Ddn_Project_Entitlement_Types_Stream_Cursor_Value_Input = { + comment?: Maybe; + value?: Maybe; +}; + +/** update columns of table "ddn.project_entitlement_types" */ +export enum Ddn_Project_Entitlement_Types_Update_Column { + /** column name */ + Comment = 'comment', + /** column name */ + Value = 'value', +} + +export type Ddn_Project_Entitlement_Types_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Ddn_Project_Entitlement_Types_Bool_Exp; +}; + /** columns and relationships of "ddn.projects" */ export type Ddn_Projects = { __typename?: 'ddn_projects'; @@ -7819,7 +10587,7 @@ export type Ddn_Projects = { builds: Array; /** An aggregate relationship */ builds_aggregate: Ddn_Build_Aggregate; - created_at: Scalars['timestamp']; + created_at: Scalars['timestamptz']; /** An array relationship */ environments: Array; /** An aggregate relationship */ @@ -7827,7 +10595,7 @@ export type Ddn_Projects = { id: Scalars['uuid']; name: Scalars['String']; owner_id: Scalars['uuid']; - updated_at: Scalars['timestamp']; + updated_at: Scalars['timestamptz']; /** An object relationship */ user: Users; }; @@ -7896,13 +10664,13 @@ export type Ddn_Projects_Bool_Exp = { _or?: Maybe>; builds?: Maybe; builds_aggregate?: Maybe; - created_at?: Maybe; + created_at?: Maybe; environments?: Maybe; environments_aggregate?: Maybe; id?: Maybe; name?: Maybe; owner_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; user?: Maybe; }; @@ -7917,33 +10685,33 @@ export enum Ddn_Projects_Constraint { /** input type for inserting data into table "ddn.projects" */ export type Ddn_Projects_Insert_Input = { builds?: Maybe; - created_at?: Maybe; + created_at?: Maybe; environments?: Maybe; id?: Maybe; name?: Maybe; owner_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; user?: Maybe; }; /** aggregate max on columns */ export type Ddn_Projects_Max_Fields = { __typename?: 'ddn_projects_max_fields'; - created_at?: Maybe; + created_at?: Maybe; id?: Maybe; name?: Maybe; owner_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** aggregate min on columns */ export type Ddn_Projects_Min_Fields = { __typename?: 'ddn_projects_min_fields'; - created_at?: Maybe; + created_at?: Maybe; id?: Maybe; name?: Maybe; owner_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** response of any mutation on the table "ddn.projects" */ @@ -8002,11 +10770,11 @@ export enum Ddn_Projects_Select_Column { /** input type for updating data in table "ddn.projects" */ export type Ddn_Projects_Set_Input = { - created_at?: Maybe; + created_at?: Maybe; id?: Maybe; name?: Maybe; owner_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** Streaming cursor of the table "ddn_projects" */ @@ -8019,11 +10787,11 @@ export type Ddn_Projects_Stream_Cursor_Input = { /** Initial value of the column from where the streaming should start */ export type Ddn_Projects_Stream_Cursor_Value_Input = { - created_at?: Maybe; + created_at?: Maybe; id?: Maybe; name?: Maybe; owner_id?: Maybe; - updated_at?: Maybe; + updated_at?: Maybe; }; /** update columns of table "ddn.projects" */ @@ -8050,6 +10818,7 @@ export type Ddn_Projects_Updates = { /** columns and relationships of "ddn.tunnel" */ export type Ddn_Tunnel = { __typename?: 'ddn_tunnel'; + created_at?: Maybe; id: Scalars['uuid']; last_connection_at: Scalars['timestamptz']; owner_id: Scalars['uuid']; @@ -8139,6 +10908,7 @@ export type Ddn_Tunnel_Bool_Exp = { _and?: Maybe>; _not?: Maybe; _or?: Maybe>; + created_at?: Maybe; id?: Maybe; last_connection_at?: Maybe; owner_id?: Maybe; @@ -8152,6 +10922,7 @@ export type Ddn_Tunnel_Bool_Exp = { export type Ddn_Tunnel_Cluster = { __typename?: 'ddn_tunnel_cluster'; cloud: Scalars['String']; + created_at?: Maybe; id: Scalars['uuid']; internal_fqdn: Scalars['String']; machine_type: Scalars['String']; @@ -8164,6 +10935,7 @@ export type Ddn_Tunnel_Cluster = { tunnels: Array; /** An aggregate relationship */ tunnels_aggregate: Ddn_Tunnel_Aggregate; + updated_at?: Maybe; zone: Scalars['String']; }; @@ -8212,6 +10984,7 @@ export type Ddn_Tunnel_Cluster_Bool_Exp = { _not?: Maybe; _or?: Maybe>; cloud?: Maybe; + created_at?: Maybe; id?: Maybe; internal_fqdn?: Maybe; machine_type?: Maybe; @@ -8221,6 +10994,7 @@ export type Ddn_Tunnel_Cluster_Bool_Exp = { regionByRegionCloud?: Maybe; tunnels?: Maybe; tunnels_aggregate?: Maybe; + updated_at?: Maybe; zone?: Maybe; }; @@ -8239,6 +11013,7 @@ export enum Ddn_Tunnel_Cluster_Constraint { /** input type for inserting data into table "ddn.tunnel_cluster" */ export type Ddn_Tunnel_Cluster_Insert_Input = { cloud?: Maybe; + created_at?: Maybe; id?: Maybe; internal_fqdn?: Maybe; machine_type?: Maybe; @@ -8247,6 +11022,7 @@ export type Ddn_Tunnel_Cluster_Insert_Input = { region?: Maybe; regionByRegionCloud?: Maybe; tunnels?: Maybe; + updated_at?: Maybe; zone?: Maybe; }; @@ -8254,12 +11030,14 @@ export type Ddn_Tunnel_Cluster_Insert_Input = { export type Ddn_Tunnel_Cluster_Max_Fields = { __typename?: 'ddn_tunnel_cluster_max_fields'; cloud?: Maybe; + created_at?: Maybe; id?: Maybe; internal_fqdn?: Maybe; machine_type?: Maybe; name?: Maybe; public_fqdn?: Maybe; region?: Maybe; + updated_at?: Maybe; zone?: Maybe; }; @@ -8267,12 +11045,14 @@ export type Ddn_Tunnel_Cluster_Max_Fields = { export type Ddn_Tunnel_Cluster_Min_Fields = { __typename?: 'ddn_tunnel_cluster_min_fields'; cloud?: Maybe; + created_at?: Maybe; id?: Maybe; internal_fqdn?: Maybe; machine_type?: Maybe; name?: Maybe; public_fqdn?: Maybe; region?: Maybe; + updated_at?: Maybe; zone?: Maybe; }; @@ -8302,6 +11082,7 @@ export type Ddn_Tunnel_Cluster_On_Conflict = { /** Ordering options when selecting data from "ddn.tunnel_cluster". */ export type Ddn_Tunnel_Cluster_Order_By = { cloud?: Maybe; + created_at?: Maybe; id?: Maybe; internal_fqdn?: Maybe; machine_type?: Maybe; @@ -8310,6 +11091,7 @@ export type Ddn_Tunnel_Cluster_Order_By = { region?: Maybe; regionByRegionCloud?: Maybe; tunnels_aggregate?: Maybe; + updated_at?: Maybe; zone?: Maybe; }; @@ -8323,6 +11105,8 @@ export enum Ddn_Tunnel_Cluster_Select_Column { /** column name */ Cloud = 'cloud', /** column name */ + CreatedAt = 'created_at', + /** column name */ Id = 'id', /** column name */ InternalFqdn = 'internal_fqdn', @@ -8335,18 +11119,22 @@ export enum Ddn_Tunnel_Cluster_Select_Column { /** column name */ Region = 'region', /** column name */ + UpdatedAt = 'updated_at', + /** column name */ Zone = 'zone', } /** input type for updating data in table "ddn.tunnel_cluster" */ export type Ddn_Tunnel_Cluster_Set_Input = { cloud?: Maybe; + created_at?: Maybe; id?: Maybe; internal_fqdn?: Maybe; machine_type?: Maybe; name?: Maybe; public_fqdn?: Maybe; region?: Maybe; + updated_at?: Maybe; zone?: Maybe; }; @@ -8361,12 +11149,14 @@ export type Ddn_Tunnel_Cluster_Stream_Cursor_Input = { /** Initial value of the column from where the streaming should start */ export type Ddn_Tunnel_Cluster_Stream_Cursor_Value_Input = { cloud?: Maybe; + created_at?: Maybe; id?: Maybe; internal_fqdn?: Maybe; machine_type?: Maybe; name?: Maybe; public_fqdn?: Maybe; region?: Maybe; + updated_at?: Maybe; zone?: Maybe; }; @@ -8375,6 +11165,8 @@ export enum Ddn_Tunnel_Cluster_Update_Column { /** column name */ Cloud = 'cloud', /** column name */ + CreatedAt = 'created_at', + /** column name */ Id = 'id', /** column name */ InternalFqdn = 'internal_fqdn', @@ -8387,6 +11179,8 @@ export enum Ddn_Tunnel_Cluster_Update_Column { /** column name */ Region = 'region', /** column name */ + UpdatedAt = 'updated_at', + /** column name */ Zone = 'zone', } @@ -8412,6 +11206,7 @@ export type Ddn_Tunnel_Inc_Input = { /** input type for inserting data into table "ddn.tunnel" */ export type Ddn_Tunnel_Insert_Input = { + created_at?: Maybe; id?: Maybe; last_connection_at?: Maybe; owner_id?: Maybe; @@ -8424,6 +11219,7 @@ export type Ddn_Tunnel_Insert_Input = { /** aggregate max on columns */ export type Ddn_Tunnel_Max_Fields = { __typename?: 'ddn_tunnel_max_fields'; + created_at?: Maybe; id?: Maybe; last_connection_at?: Maybe; owner_id?: Maybe; @@ -8433,6 +11229,7 @@ export type Ddn_Tunnel_Max_Fields = { /** order by max() on columns of table "ddn.tunnel" */ export type Ddn_Tunnel_Max_Order_By = { + created_at?: Maybe; id?: Maybe; last_connection_at?: Maybe; owner_id?: Maybe; @@ -8443,6 +11240,7 @@ export type Ddn_Tunnel_Max_Order_By = { /** aggregate min on columns */ export type Ddn_Tunnel_Min_Fields = { __typename?: 'ddn_tunnel_min_fields'; + created_at?: Maybe; id?: Maybe; last_connection_at?: Maybe; owner_id?: Maybe; @@ -8452,6 +11250,7 @@ export type Ddn_Tunnel_Min_Fields = { /** order by min() on columns of table "ddn.tunnel" */ export type Ddn_Tunnel_Min_Order_By = { + created_at?: Maybe; id?: Maybe; last_connection_at?: Maybe; owner_id?: Maybe; @@ -8477,6 +11276,7 @@ export type Ddn_Tunnel_On_Conflict = { /** Ordering options when selecting data from "ddn.tunnel". */ export type Ddn_Tunnel_Order_By = { + created_at?: Maybe; id?: Maybe; last_connection_at?: Maybe; owner_id?: Maybe; @@ -8493,6 +11293,8 @@ export type Ddn_Tunnel_Pk_Columns_Input = { /** select columns of table "ddn.tunnel" */ export enum Ddn_Tunnel_Select_Column { + /** column name */ + CreatedAt = 'created_at', /** column name */ Id = 'id', /** column name */ @@ -8507,6 +11309,7 @@ export enum Ddn_Tunnel_Select_Column { /** input type for updating data in table "ddn.tunnel" */ export type Ddn_Tunnel_Set_Input = { + created_at?: Maybe; id?: Maybe; last_connection_at?: Maybe; owner_id?: Maybe; @@ -8557,6 +11360,7 @@ export type Ddn_Tunnel_Stream_Cursor_Input = { /** Initial value of the column from where the streaming should start */ export type Ddn_Tunnel_Stream_Cursor_Value_Input = { + created_at?: Maybe; id?: Maybe; last_connection_at?: Maybe; owner_id?: Maybe; @@ -8577,6 +11381,8 @@ export type Ddn_Tunnel_Sum_Order_By = { /** update columns of table "ddn.tunnel" */ export enum Ddn_Tunnel_Update_Column { + /** column name */ + CreatedAt = 'created_at', /** column name */ Id = 'id', /** column name */ @@ -8640,6 +11446,7 @@ export type DdnApplyMetadataOutput = { export type DdnCreateBuildOutput = { __typename?: 'ddnCreateBuildOutput'; + build?: Maybe; build_id: Scalars['String']; build_version: Scalars['String']; graphql_api_endpoint: Scalars['String']; @@ -8649,6 +11456,23 @@ export type DdnCreateProjectResponse = { __typename?: 'DDNCreateProjectResponse'; id: Scalars['uuid']; name: Scalars['String']; + project?: Maybe; +}; + +export type DdnTunnel = { + __typename?: 'DDNTunnel'; + id: Scalars['uuid']; + owner_id: Scalars['uuid']; + reserved_cluster: Scalars['uuid']; + reserved_port: Scalars['Int']; + tunnel_cluster: DdnTunnelCluster; +}; + +export type DdnTunnelCluster = { + __typename?: 'DDNTunnelCluster'; + internal_fqdn: Scalars['String']; + name: Scalars['String']; + public_fqdn: Scalars['String']; }; /** Table to keep track of dedicated cloud bills. These are not part of automated Stripe invoicing. */ @@ -8658,6 +11482,10 @@ export type Dedicated_Cloud_Bills = { created_at: Scalars['timestamptz']; cu_cost: Scalars['Int']; data_passthrough_cost: Scalars['Int']; + /** An array relationship */ + details: Array; + /** An aggregate relationship */ + details_aggregate: Dedicated_Cloud_Bills_Details_Aggregate; id: Scalars['uuid']; metadata?: Maybe; month: Scalars['Int']; @@ -8666,6 +11494,24 @@ export type Dedicated_Cloud_Bills = { year: Scalars['Int']; }; +/** Table to keep track of dedicated cloud bills. These are not part of automated Stripe invoicing. */ +export type Dedicated_Cloud_BillsDetailsArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +/** Table to keep track of dedicated cloud bills. These are not part of automated Stripe invoicing. */ +export type Dedicated_Cloud_BillsDetails_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + /** Table to keep track of dedicated cloud bills. These are not part of automated Stripe invoicing. */ export type Dedicated_Cloud_BillsMetadataArgs = { path?: Maybe; @@ -8764,6 +11610,8 @@ export type Dedicated_Cloud_Bills_Bool_Exp = { created_at?: Maybe; cu_cost?: Maybe; data_passthrough_cost?: Maybe; + details?: Maybe; + details_aggregate?: Maybe; id?: Maybe; metadata?: Maybe; month?: Maybe; @@ -8798,6 +11646,419 @@ export type Dedicated_Cloud_Bills_Delete_Key_Input = { metadata?: Maybe; }; +/** Granular details about compute unit usage based bills */ +export type Dedicated_Cloud_Bills_Details = { + __typename?: 'dedicated_cloud_bills_details'; + bill_id: Scalars['uuid']; + created_at: Scalars['timestamptz']; + details?: Maybe; + id: Scalars['uuid']; + month: Scalars['Int']; + updated_at: Scalars['timestamptz']; + year: Scalars['Int']; +}; + +/** Granular details about compute unit usage based bills */ +export type Dedicated_Cloud_Bills_DetailsDetailsArgs = { + path?: Maybe; +}; + +/** aggregated selection of "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Aggregate = { + __typename?: 'dedicated_cloud_bills_details_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +export type Dedicated_Cloud_Bills_Details_Aggregate_Bool_Exp = { + count?: Maybe; +}; + +export type Dedicated_Cloud_Bills_Details_Aggregate_Bool_Exp_Count = { + arguments?: Maybe>; + distinct?: Maybe; + filter?: Maybe; + predicate: Int_Comparison_Exp; +}; + +/** aggregate fields of "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Aggregate_Fields = { + __typename?: 'dedicated_cloud_bills_details_aggregate_fields'; + avg?: Maybe; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; + stddev?: Maybe; + stddev_pop?: Maybe; + stddev_samp?: Maybe; + sum?: Maybe; + var_pop?: Maybe; + var_samp?: Maybe; + variance?: Maybe; +}; + +/** aggregate fields of "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** order by aggregate values of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Aggregate_Order_By = { + avg?: Maybe; + count?: Maybe; + max?: Maybe; + min?: Maybe; + stddev?: Maybe; + stddev_pop?: Maybe; + stddev_samp?: Maybe; + sum?: Maybe; + var_pop?: Maybe; + var_samp?: Maybe; + variance?: Maybe; +}; + +/** append existing jsonb value of filtered columns with new jsonb value */ +export type Dedicated_Cloud_Bills_Details_Append_Input = { + details?: Maybe; +}; + +/** input type for inserting array relation for remote table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Arr_Rel_Insert_Input = { + data: Array; + /** upsert condition */ + on_conflict?: Maybe; +}; + +/** aggregate avg on columns */ +export type Dedicated_Cloud_Bills_Details_Avg_Fields = { + __typename?: 'dedicated_cloud_bills_details_avg_fields'; + month?: Maybe; + year?: Maybe; +}; + +/** order by avg() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Avg_Order_By = { + month?: Maybe; + year?: Maybe; +}; + +/** + * Boolean expression to filter rows from the table + * "dedicated_cloud_bills_details". All fields are combined with a logical 'AND'. + */ +export type Dedicated_Cloud_Bills_Details_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + bill_id?: Maybe; + created_at?: Maybe; + details?: Maybe; + id?: Maybe; + month?: Maybe; + updated_at?: Maybe; + year?: Maybe; +}; + +/** unique or primary key constraints on table "dedicated_cloud_bills_details" */ +export enum Dedicated_Cloud_Bills_Details_Constraint { + /** unique or primary key constraint on columns "id" */ + DedicatedCloudBillsDetailsPkey = 'dedicated_cloud_bills_details_pkey', +} + +/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */ +export type Dedicated_Cloud_Bills_Details_Delete_At_Path_Input = { + details?: Maybe>; +}; + +/** + * delete the array element with specified index (negative integers count from the + * end). throws an error if top level container is not an array + */ +export type Dedicated_Cloud_Bills_Details_Delete_Elem_Input = { + details?: Maybe; +}; + +/** delete key/value pair or string element. key/value pairs are matched based on their key value */ +export type Dedicated_Cloud_Bills_Details_Delete_Key_Input = { + details?: Maybe; +}; + +/** input type for incrementing numeric columns in table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Inc_Input = { + month?: Maybe; + year?: Maybe; +}; + +/** input type for inserting data into table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Insert_Input = { + bill_id?: Maybe; + created_at?: Maybe; + details?: Maybe; + id?: Maybe; + month?: Maybe; + updated_at?: Maybe; + year?: Maybe; +}; + +/** aggregate max on columns */ +export type Dedicated_Cloud_Bills_Details_Max_Fields = { + __typename?: 'dedicated_cloud_bills_details_max_fields'; + bill_id?: Maybe; + created_at?: Maybe; + id?: Maybe; + month?: Maybe; + updated_at?: Maybe; + year?: Maybe; +}; + +/** order by max() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Max_Order_By = { + bill_id?: Maybe; + created_at?: Maybe; + id?: Maybe; + month?: Maybe; + updated_at?: Maybe; + year?: Maybe; +}; + +/** aggregate min on columns */ +export type Dedicated_Cloud_Bills_Details_Min_Fields = { + __typename?: 'dedicated_cloud_bills_details_min_fields'; + bill_id?: Maybe; + created_at?: Maybe; + id?: Maybe; + month?: Maybe; + updated_at?: Maybe; + year?: Maybe; +}; + +/** order by min() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Min_Order_By = { + bill_id?: Maybe; + created_at?: Maybe; + id?: Maybe; + month?: Maybe; + updated_at?: Maybe; + year?: Maybe; +}; + +/** response of any mutation on the table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Mutation_Response = { + __typename?: 'dedicated_cloud_bills_details_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** on_conflict condition type for table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_On_Conflict = { + constraint: Dedicated_Cloud_Bills_Details_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "dedicated_cloud_bills_details". */ +export type Dedicated_Cloud_Bills_Details_Order_By = { + bill_id?: Maybe; + created_at?: Maybe; + details?: Maybe; + id?: Maybe; + month?: Maybe; + updated_at?: Maybe; + year?: Maybe; +}; + +/** primary key columns input for table: dedicated_cloud_bills_details */ +export type Dedicated_Cloud_Bills_Details_Pk_Columns_Input = { + id: Scalars['uuid']; +}; + +/** prepend existing jsonb value of filtered columns with new jsonb value */ +export type Dedicated_Cloud_Bills_Details_Prepend_Input = { + details?: Maybe; +}; + +/** select columns of table "dedicated_cloud_bills_details" */ +export enum Dedicated_Cloud_Bills_Details_Select_Column { + /** column name */ + BillId = 'bill_id', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Details = 'details', + /** column name */ + Id = 'id', + /** column name */ + Month = 'month', + /** column name */ + UpdatedAt = 'updated_at', + /** column name */ + Year = 'year', +} + +/** input type for updating data in table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Set_Input = { + bill_id?: Maybe; + created_at?: Maybe; + details?: Maybe; + id?: Maybe; + month?: Maybe; + updated_at?: Maybe; + year?: Maybe; +}; + +/** aggregate stddev on columns */ +export type Dedicated_Cloud_Bills_Details_Stddev_Fields = { + __typename?: 'dedicated_cloud_bills_details_stddev_fields'; + month?: Maybe; + year?: Maybe; +}; + +/** order by stddev() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Stddev_Order_By = { + month?: Maybe; + year?: Maybe; +}; + +/** aggregate stddev_pop on columns */ +export type Dedicated_Cloud_Bills_Details_Stddev_Pop_Fields = { + __typename?: 'dedicated_cloud_bills_details_stddev_pop_fields'; + month?: Maybe; + year?: Maybe; +}; + +/** order by stddev_pop() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Stddev_Pop_Order_By = { + month?: Maybe; + year?: Maybe; +}; + +/** aggregate stddev_samp on columns */ +export type Dedicated_Cloud_Bills_Details_Stddev_Samp_Fields = { + __typename?: 'dedicated_cloud_bills_details_stddev_samp_fields'; + month?: Maybe; + year?: Maybe; +}; + +/** order by stddev_samp() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Stddev_Samp_Order_By = { + month?: Maybe; + year?: Maybe; +}; + +/** Streaming cursor of the table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Dedicated_Cloud_Bills_Details_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Dedicated_Cloud_Bills_Details_Stream_Cursor_Value_Input = { + bill_id?: Maybe; + created_at?: Maybe; + details?: Maybe; + id?: Maybe; + month?: Maybe; + updated_at?: Maybe; + year?: Maybe; +}; + +/** aggregate sum on columns */ +export type Dedicated_Cloud_Bills_Details_Sum_Fields = { + __typename?: 'dedicated_cloud_bills_details_sum_fields'; + month?: Maybe; + year?: Maybe; +}; + +/** order by sum() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Sum_Order_By = { + month?: Maybe; + year?: Maybe; +}; + +/** update columns of table "dedicated_cloud_bills_details" */ +export enum Dedicated_Cloud_Bills_Details_Update_Column { + /** column name */ + BillId = 'bill_id', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Details = 'details', + /** column name */ + Id = 'id', + /** column name */ + Month = 'month', + /** column name */ + UpdatedAt = 'updated_at', + /** column name */ + Year = 'year', +} + +export type Dedicated_Cloud_Bills_Details_Updates = { + /** append existing jsonb value of filtered columns with new jsonb value */ + _append?: Maybe; + /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */ + _delete_at_path?: Maybe; + /** + * delete the array element with specified index (negative integers count from + * the end). throws an error if top level container is not an array + */ + _delete_elem?: Maybe; + /** delete key/value pair or string element. key/value pairs are matched based on their key value */ + _delete_key?: Maybe; + /** increments the numeric columns with given value of the filtered values */ + _inc?: Maybe; + /** prepend existing jsonb value of filtered columns with new jsonb value */ + _prepend?: Maybe; + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Dedicated_Cloud_Bills_Details_Bool_Exp; +}; + +/** aggregate var_pop on columns */ +export type Dedicated_Cloud_Bills_Details_Var_Pop_Fields = { + __typename?: 'dedicated_cloud_bills_details_var_pop_fields'; + month?: Maybe; + year?: Maybe; +}; + +/** order by var_pop() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Var_Pop_Order_By = { + month?: Maybe; + year?: Maybe; +}; + +/** aggregate var_samp on columns */ +export type Dedicated_Cloud_Bills_Details_Var_Samp_Fields = { + __typename?: 'dedicated_cloud_bills_details_var_samp_fields'; + month?: Maybe; + year?: Maybe; +}; + +/** order by var_samp() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Var_Samp_Order_By = { + month?: Maybe; + year?: Maybe; +}; + +/** aggregate variance on columns */ +export type Dedicated_Cloud_Bills_Details_Variance_Fields = { + __typename?: 'dedicated_cloud_bills_details_variance_fields'; + month?: Maybe; + year?: Maybe; +}; + +/** order by variance() on columns of table "dedicated_cloud_bills_details" */ +export type Dedicated_Cloud_Bills_Details_Variance_Order_By = { + month?: Maybe; + year?: Maybe; +}; + /** input type for incrementing numeric columns in table "dedicated_cloud_bills" */ export type Dedicated_Cloud_Bills_Inc_Input = { cu_cost?: Maybe; @@ -8812,6 +12073,7 @@ export type Dedicated_Cloud_Bills_Insert_Input = { created_at?: Maybe; cu_cost?: Maybe; data_passthrough_cost?: Maybe; + details?: Maybe; id?: Maybe; metadata?: Maybe; month?: Maybe; @@ -8896,6 +12158,7 @@ export type Dedicated_Cloud_Bills_Order_By = { created_at?: Maybe; cu_cost?: Maybe; data_passthrough_cost?: Maybe; + details_aggregate?: Maybe; id?: Maybe; metadata?: Maybe; month?: Maybe; @@ -10805,11 +14068,20 @@ export type DeleteProjectResponse = { id: Scalars['uuid']; }; +export type DeleteSlackAppOutput = { + __typename?: 'DeleteSlackAppOutput'; + status: Scalars['String']; +}; + export type DeleteUserResponse = { __typename?: 'deleteUserResponse'; status: Scalars['String']; }; +export type DelteSlackAppPayload = { + projectID: Scalars['uuid']; +}; + export type DeployLatestCommitStatus = { __typename?: 'DeployLatestCommitStatus'; status: Scalars['String']; @@ -12636,6 +15908,8 @@ export enum Feature_Enum { GcpSupport = 'GCPSupport', /** Allows user to automatically deploy metadata/migrations to the project from github repo */ GithubIntegration = 'GithubIntegration', + /** Allows users to have access to GraphQL Schema Registry */ + GraphQlSchemaRegistry = 'GraphQLSchemaRegistry', /** Neon DB Integration through Hasura Console */ NeonDatabaseIntegration = 'NeonDatabaseIntegration', /** Allows user to create Hasura Pro Project */ @@ -13696,13 +16970,6 @@ export type Get_Aggregated_Cost_For_Project_On_Shared_Plan_Args = { todate?: Maybe; }; -export type Get_Previous_Schema_Change_For_Role_Args = { - current_change_recorded_at?: Maybe; - search_project_id?: Maybe; - search_schema_id?: Maybe; - search_schema_role?: Maybe; -}; - export type GetReportUrlResponse = { __typename?: 'GetReportURLResponse'; url: Scalars['String']; @@ -15766,214 +19033,6 @@ export type Hasura_Cluster_Updates = { where: Hasura_Cluster_Bool_Exp; }; -/** Many-to-many relationship table between schemas and tags */ -export type Hasura_Graphql_Schema_Tags = { - __typename?: 'hasura_graphql_schema_tags'; - /** An object relationship */ - hasura_graphql_schema: Schema_Diff_Data; - hasura_graphql_schema_id: Scalars['uuid']; - id: Scalars['uuid']; - /** An object relationship */ - tag: Tag; - tag_id: Scalars['uuid']; - user_id: Scalars['uuid']; -}; - -/** aggregated selection of "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Aggregate = { - __typename?: 'hasura_graphql_schema_tags_aggregate'; - aggregate?: Maybe; - nodes: Array; -}; - -export type Hasura_Graphql_Schema_Tags_Aggregate_Bool_Exp = { - count?: Maybe; -}; - -export type Hasura_Graphql_Schema_Tags_Aggregate_Bool_Exp_Count = { - arguments?: Maybe>; - distinct?: Maybe; - filter?: Maybe; - predicate: Int_Comparison_Exp; -}; - -/** aggregate fields of "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Aggregate_Fields = { - __typename?: 'hasura_graphql_schema_tags_aggregate_fields'; - count: Scalars['Int']; - max?: Maybe; - min?: Maybe; -}; - -/** aggregate fields of "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Aggregate_FieldsCountArgs = { - columns?: Maybe>; - distinct?: Maybe; -}; - -/** order by aggregate values of table "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Aggregate_Order_By = { - count?: Maybe; - max?: Maybe; - min?: Maybe; -}; - -/** input type for inserting array relation for remote table "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Arr_Rel_Insert_Input = { - data: Array; - /** upsert condition */ - on_conflict?: Maybe; -}; - -/** Boolean expression to filter rows from the table "hasura_graphql_schema_tags". All fields are combined with a logical 'AND'. */ -export type Hasura_Graphql_Schema_Tags_Bool_Exp = { - _and?: Maybe>; - _not?: Maybe; - _or?: Maybe>; - hasura_graphql_schema?: Maybe; - hasura_graphql_schema_id?: Maybe; - id?: Maybe; - tag?: Maybe; - tag_id?: Maybe; - user_id?: Maybe; -}; - -/** unique or primary key constraints on table "hasura_graphql_schema_tags" */ -export enum Hasura_Graphql_Schema_Tags_Constraint { - /** unique or primary key constraint on columns "id" */ - HasuraGraphqlSchemaTagsPkey = 'hasura_graphql_schema_tags_pkey', -} - -/** input type for inserting data into table "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Insert_Input = { - hasura_graphql_schema?: Maybe; - hasura_graphql_schema_id?: Maybe; - id?: Maybe; - tag?: Maybe; - tag_id?: Maybe; - user_id?: Maybe; -}; - -/** aggregate max on columns */ -export type Hasura_Graphql_Schema_Tags_Max_Fields = { - __typename?: 'hasura_graphql_schema_tags_max_fields'; - hasura_graphql_schema_id?: Maybe; - id?: Maybe; - tag_id?: Maybe; - user_id?: Maybe; -}; - -/** order by max() on columns of table "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Max_Order_By = { - hasura_graphql_schema_id?: Maybe; - id?: Maybe; - tag_id?: Maybe; - user_id?: Maybe; -}; - -/** aggregate min on columns */ -export type Hasura_Graphql_Schema_Tags_Min_Fields = { - __typename?: 'hasura_graphql_schema_tags_min_fields'; - hasura_graphql_schema_id?: Maybe; - id?: Maybe; - tag_id?: Maybe; - user_id?: Maybe; -}; - -/** order by min() on columns of table "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Min_Order_By = { - hasura_graphql_schema_id?: Maybe; - id?: Maybe; - tag_id?: Maybe; - user_id?: Maybe; -}; - -/** response of any mutation on the table "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Mutation_Response = { - __typename?: 'hasura_graphql_schema_tags_mutation_response'; - /** number of rows affected by the mutation */ - affected_rows: Scalars['Int']; - /** data from the rows affected by the mutation */ - returning: Array; -}; - -/** on_conflict condition type for table "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_On_Conflict = { - constraint: Hasura_Graphql_Schema_Tags_Constraint; - update_columns?: Array; - where?: Maybe; -}; - -/** Ordering options when selecting data from "hasura_graphql_schema_tags". */ -export type Hasura_Graphql_Schema_Tags_Order_By = { - hasura_graphql_schema?: Maybe; - hasura_graphql_schema_id?: Maybe; - id?: Maybe; - tag?: Maybe; - tag_id?: Maybe; - user_id?: Maybe; -}; - -/** primary key columns input for table: hasura_graphql_schema_tags */ -export type Hasura_Graphql_Schema_Tags_Pk_Columns_Input = { - id: Scalars['uuid']; -}; - -/** select columns of table "hasura_graphql_schema_tags" */ -export enum Hasura_Graphql_Schema_Tags_Select_Column { - /** column name */ - HasuraGraphqlSchemaId = 'hasura_graphql_schema_id', - /** column name */ - Id = 'id', - /** column name */ - TagId = 'tag_id', - /** column name */ - UserId = 'user_id', -} - -/** input type for updating data in table "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Set_Input = { - hasura_graphql_schema_id?: Maybe; - id?: Maybe; - tag_id?: Maybe; - user_id?: Maybe; -}; - -/** Streaming cursor of the table "hasura_graphql_schema_tags" */ -export type Hasura_Graphql_Schema_Tags_Stream_Cursor_Input = { - /** Stream column input with initial value */ - initial_value: Hasura_Graphql_Schema_Tags_Stream_Cursor_Value_Input; - /** cursor ordering */ - ordering?: Maybe; -}; - -/** Initial value of the column from where the streaming should start */ -export type Hasura_Graphql_Schema_Tags_Stream_Cursor_Value_Input = { - hasura_graphql_schema_id?: Maybe; - id?: Maybe; - tag_id?: Maybe; - user_id?: Maybe; -}; - -/** update columns of table "hasura_graphql_schema_tags" */ -export enum Hasura_Graphql_Schema_Tags_Update_Column { - /** column name */ - HasuraGraphqlSchemaId = 'hasura_graphql_schema_id', - /** column name */ - Id = 'id', - /** column name */ - TagId = 'tag_id', - /** column name */ - UserId = 'user_id', -} - -export type Hasura_Graphql_Schema_Tags_Updates = { - /** sets the columns of the filtered rows to the given values */ - _set?: Maybe; - /** filter the rows which have to be updated */ - where: Hasura_Graphql_Schema_Tags_Bool_Exp; -}; - /** Multi-tenant Hasura process capable of providing GraphQL APIs */ export type Hasura_Worker = { __typename?: 'hasura_worker'; @@ -17792,17 +20851,6 @@ export type Insert_Db_Usage_Args = { project_ids?: Maybe; }; -export type Insert_Schema_Registry_Changes_Input = { - admin_schema_hash: Scalars['String']; - change_recorded_at: Scalars['String']; - is_metadata_inconsistent: Scalars['Boolean']; - metadata_resource_version: Scalars['Int']; - project_id: Scalars['uuid']; - schema_details: Array>; - tenant_id?: Maybe; - worker_id?: Maybe; -}; - /** Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'. */ export type Int_Comparison_Exp = { _eq?: Maybe; @@ -21644,6 +24692,22 @@ export type Mutation_Root = { changeUserEmail: ChangeUserEmailRequest; checkDBLatency?: Maybe; completeChangeUserEmailRequest: ChangeUserEmailRequest; + /** delete data from the table: "connector_deployment" */ + connector_delete_connector_deployment?: Maybe; + /** delete single row from the table: "connector_deployment" */ + connector_delete_connector_deployment_by_pk?: Maybe; + /** insert data into the table: "connector_deployment" */ + connector_insert_connector_deployment?: Maybe; + /** insert a single row into the table: "connector_deployment" */ + connector_insert_connector_deployment_one?: Maybe; + /** update data of the table: "connector_deployment" */ + connector_update_connector_deployment?: Maybe; + /** update single row of the table: "connector_deployment" */ + connector_update_connector_deployment_by_pk?: Maybe; + /** update multiples rows of table: "connector_deployment" */ + connector_update_connector_deployment_many?: Maybe< + Array> + >; /** Internal utility action to convert a project's entitlements and plan to dedicated_cloud */ convertToDedicatedCloud?: Maybe; createDedicatedVPC?: Maybe; @@ -21659,11 +24723,32 @@ export type Mutation_Root = { /** ddnCreateBuild */ ddnCreateBuild?: Maybe; ddnCreateProject?: Maybe; + ddnCreateTunnel?: Maybe; ddnHasuraSecretDelete: HasuraSecretMessage; ddnHasuraSecretSet: HasuraSecretMessage; declineBillingManagerInvite?: Maybe; declineInvite: ProjectCollaboratorInvitation; declineTransferOwnershipInvite: ProjectOwnershipTransferInvitation; + /** delete data from the table: "alert_config" */ + delete_alert_config?: Maybe; + /** delete data from the table: "alert_config_alert_type" */ + delete_alert_config_alert_type?: Maybe; + /** delete single row from the table: "alert_config_alert_type" */ + delete_alert_config_alert_type_by_pk?: Maybe; + /** delete single row from the table: "alert_config" */ + delete_alert_config_by_pk?: Maybe; + /** delete data from the table: "alert_config_service" */ + delete_alert_config_service?: Maybe; + /** delete single row from the table: "alert_config_service" */ + delete_alert_config_service_by_pk?: Maybe; + /** delete data from the table: "alert_service_type" */ + delete_alert_service_type?: Maybe; + /** delete single row from the table: "alert_service_type" */ + delete_alert_service_type_by_pk?: Maybe; + /** delete data from the table: "alert_type" */ + delete_alert_type?: Maybe; + /** delete single row from the table: "alert_type" */ + delete_alert_type_by_pk?: Maybe; /** delete data from the table: "azuremonitor_config" */ delete_azuremonitor_config?: Maybe; /** delete single row from the table: "azuremonitor_config" */ @@ -21708,6 +24793,14 @@ export type Mutation_Root = { delete_config_status?: Maybe; /** delete single row from the table: "config_status" */ delete_config_status_by_pk?: Maybe; + /** delete data from the table: "connector_config" */ + delete_connector_config?: Maybe; + /** delete single row from the table: "connector_config" */ + delete_connector_config_by_pk?: Maybe; + /** delete data from the table: "connector_deployments" */ + delete_connector_deployments?: Maybe; + /** delete single row from the table: "connector_deployments" */ + delete_connector_deployments_by_pk?: Maybe; /** delete data from the table: "coupon" */ delete_coupon?: Maybe; /** delete single row from the table: "coupon" */ @@ -21764,6 +24857,18 @@ export type Mutation_Root = { delete_ddn_environment?: Maybe; /** delete single row from the table: "ddn.environment" */ delete_ddn_environment_by_pk?: Maybe; + /** delete data from the table: "ddn.project_entitlement_access" */ + delete_ddn_project_entitlement_access?: Maybe; + /** delete single row from the table: "ddn.project_entitlement_access" */ + delete_ddn_project_entitlement_access_by_pk?: Maybe; + /** delete data from the table: "ddn.project_entitlement_catalogue" */ + delete_ddn_project_entitlement_catalogue?: Maybe; + /** delete single row from the table: "ddn.project_entitlement_catalogue" */ + delete_ddn_project_entitlement_catalogue_by_pk?: Maybe; + /** delete data from the table: "ddn.project_entitlement_types" */ + delete_ddn_project_entitlement_types?: Maybe; + /** delete single row from the table: "ddn.project_entitlement_types" */ + delete_ddn_project_entitlement_types_by_pk?: Maybe; /** delete data from the table: "ddn.projects" */ delete_ddn_projects?: Maybe; /** delete single row from the table: "ddn.projects" */ @@ -21780,6 +24885,10 @@ export type Mutation_Root = { delete_dedicated_cloud_bills?: Maybe; /** delete single row from the table: "dedicated_cloud_bills" */ delete_dedicated_cloud_bills_by_pk?: Maybe; + /** delete data from the table: "dedicated_cloud_bills_details" */ + delete_dedicated_cloud_bills_details?: Maybe; + /** delete single row from the table: "dedicated_cloud_bills_details" */ + delete_dedicated_cloud_bills_details_by_pk?: Maybe; /** delete data from the table: "dedicated_cloud_commitments" */ delete_dedicated_cloud_commitments?: Maybe; /** delete single row from the table: "dedicated_cloud_commitments" */ @@ -21872,10 +24981,6 @@ export type Mutation_Root = { delete_hasura_cluster?: Maybe; /** delete single row from the table: "hasura_cluster" */ delete_hasura_cluster_by_pk?: Maybe; - /** delete data from the table: "hasura_graphql_schema_tags" */ - delete_hasura_graphql_schema_tags?: Maybe; - /** delete single row from the table: "hasura_graphql_schema_tags" */ - delete_hasura_graphql_schema_tags_by_pk?: Maybe; /** delete data from the table: "hasura_worker" */ delete_hasura_worker?: Maybe; /** delete single row from the table: "hasura_worker" */ @@ -22162,16 +25267,12 @@ export type Mutation_Root = { delete_saml_idp?: Maybe; /** delete single row from the table: "saml_idp" */ delete_saml_idp_by_pk?: Maybe; - /** delete data from the table: "schema_diff_data" */ - delete_schema_diff_data?: Maybe; - /** delete single row from the table: "schema_diff_data" */ - delete_schema_diff_data_by_pk?: Maybe; - /** delete data from the table: "schema_registry_dumps" */ - delete_schema_registry_dumps?: Maybe; - /** delete single row from the table: "schema_registry_dumps" */ - delete_schema_registry_dumps_by_pk?: Maybe; /** delete data from the table: "search_project_login_status_results" */ delete_search_project_login_status_results?: Maybe; + /** delete data from the table: "slack_config" */ + delete_slack_config?: Maybe; + /** delete single row from the table: "slack_config" */ + delete_slack_config_by_pk?: Maybe; /** delete data from the table: "stripe_subscription" */ delete_stripe_subscription?: Maybe; /** delete single row from the table: "stripe_subscription" */ @@ -22244,10 +25345,6 @@ export type Mutation_Root = { delete_survey_v2_response_answer_option_by_pk?: Maybe; /** delete single row from the table: "survey_v2_response" */ delete_survey_v2_response_by_pk?: Maybe; - /** delete data from the table: "tag" */ - delete_tag?: Maybe; - /** delete single row from the table: "tag" */ - delete_tag_by_pk?: Maybe; /** delete data from the table: "task_event" */ delete_task_event?: Maybe; /** delete single row from the table: "task_event" */ @@ -22364,14 +25461,13 @@ export type Mutation_Root = { delete_zendesk_support_tickets_by_pk?: Maybe; deleteCard?: Maybe; deleteProject: DeleteProjectResponse; + /** deletes the slack app integrated with the project ID. */ + deleteSlackApp?: Maybe; deleteTenant?: Maybe; deleteTenantEnv?: Maybe; deleteUser?: Maybe; deployLatestGithubCommit?: Maybe; enableCloudflareProxy?: Maybe; - fetchDedicatedCloudClusterBills?: Maybe< - Array - >; getGithubSession?: Maybe; getHerokuSession?: Maybe; githubTokenExchange?: Maybe; @@ -22382,6 +25478,26 @@ export type Mutation_Root = { herokuUnregisterWebhook: WebhookUnregisterStatus; herokuUnregisterWebhookVar: WebhookUnregisterStatus; initiateStripeAddCardProcess: ClientSecretInfo; + /** insert data into the table: "alert_config" */ + insert_alert_config?: Maybe; + /** insert data into the table: "alert_config_alert_type" */ + insert_alert_config_alert_type?: Maybe; + /** insert a single row into the table: "alert_config_alert_type" */ + insert_alert_config_alert_type_one?: Maybe; + /** insert a single row into the table: "alert_config" */ + insert_alert_config_one?: Maybe; + /** insert data into the table: "alert_config_service" */ + insert_alert_config_service?: Maybe; + /** insert a single row into the table: "alert_config_service" */ + insert_alert_config_service_one?: Maybe; + /** insert data into the table: "alert_service_type" */ + insert_alert_service_type?: Maybe; + /** insert a single row into the table: "alert_service_type" */ + insert_alert_service_type_one?: Maybe; + /** insert data into the table: "alert_type" */ + insert_alert_type?: Maybe; + /** insert a single row into the table: "alert_type" */ + insert_alert_type_one?: Maybe; /** insert data into the table: "azuremonitor_config" */ insert_azuremonitor_config?: Maybe; /** insert a single row into the table: "azuremonitor_config" */ @@ -22430,6 +25546,14 @@ export type Mutation_Root = { insert_config_status?: Maybe; /** insert a single row into the table: "config_status" */ insert_config_status_one?: Maybe; + /** insert data into the table: "connector_config" */ + insert_connector_config?: Maybe; + /** insert a single row into the table: "connector_config" */ + insert_connector_config_one?: Maybe; + /** insert data into the table: "connector_deployments" */ + insert_connector_deployments?: Maybe; + /** insert a single row into the table: "connector_deployments" */ + insert_connector_deployments_one?: Maybe; /** insert data into the table: "coupon" */ insert_coupon?: Maybe; /** insert data into the table: "coupon_duration" */ @@ -22488,6 +25612,18 @@ export type Mutation_Root = { insert_ddn_environment?: Maybe; /** insert a single row into the table: "ddn.environment" */ insert_ddn_environment_one?: Maybe; + /** insert data into the table: "ddn.project_entitlement_access" */ + insert_ddn_project_entitlement_access?: Maybe; + /** insert a single row into the table: "ddn.project_entitlement_access" */ + insert_ddn_project_entitlement_access_one?: Maybe; + /** insert data into the table: "ddn.project_entitlement_catalogue" */ + insert_ddn_project_entitlement_catalogue?: Maybe; + /** insert a single row into the table: "ddn.project_entitlement_catalogue" */ + insert_ddn_project_entitlement_catalogue_one?: Maybe; + /** insert data into the table: "ddn.project_entitlement_types" */ + insert_ddn_project_entitlement_types?: Maybe; + /** insert a single row into the table: "ddn.project_entitlement_types" */ + insert_ddn_project_entitlement_types_one?: Maybe; /** insert data into the table: "ddn.projects" */ insert_ddn_projects?: Maybe; /** insert a single row into the table: "ddn.projects" */ @@ -22502,6 +25638,10 @@ export type Mutation_Root = { insert_ddn_tunnel_one?: Maybe; /** insert data into the table: "dedicated_cloud_bills" */ insert_dedicated_cloud_bills?: Maybe; + /** insert data into the table: "dedicated_cloud_bills_details" */ + insert_dedicated_cloud_bills_details?: Maybe; + /** insert a single row into the table: "dedicated_cloud_bills_details" */ + insert_dedicated_cloud_bills_details_one?: Maybe; /** insert a single row into the table: "dedicated_cloud_bills" */ insert_dedicated_cloud_bills_one?: Maybe; /** insert data into the table: "dedicated_cloud_commitments" */ @@ -22596,10 +25736,6 @@ export type Mutation_Root = { insert_hasura_cluster?: Maybe; /** insert a single row into the table: "hasura_cluster" */ insert_hasura_cluster_one?: Maybe; - /** insert data into the table: "hasura_graphql_schema_tags" */ - insert_hasura_graphql_schema_tags?: Maybe; - /** insert a single row into the table: "hasura_graphql_schema_tags" */ - insert_hasura_graphql_schema_tags_one?: Maybe; /** insert data into the table: "hasura_worker" */ insert_hasura_worker?: Maybe; /** insert a single row into the table: "hasura_worker" */ @@ -22904,18 +26040,14 @@ export type Mutation_Root = { insert_saml_idp?: Maybe; /** insert a single row into the table: "saml_idp" */ insert_saml_idp_one?: Maybe; - /** insert data into the table: "schema_diff_data" */ - insert_schema_diff_data?: Maybe; - /** insert a single row into the table: "schema_diff_data" */ - insert_schema_diff_data_one?: Maybe; - /** insert data into the table: "schema_registry_dumps" */ - insert_schema_registry_dumps?: Maybe; - /** insert a single row into the table: "schema_registry_dumps" */ - insert_schema_registry_dumps_one?: Maybe; /** insert data into the table: "search_project_login_status_results" */ insert_search_project_login_status_results?: Maybe; /** insert a single row into the table: "search_project_login_status_results" */ insert_search_project_login_status_results_one?: Maybe; + /** insert data into the table: "slack_config" */ + insert_slack_config?: Maybe; + /** insert a single row into the table: "slack_config" */ + insert_slack_config_one?: Maybe; /** insert data into the table: "stripe_subscription" */ insert_stripe_subscription?: Maybe; /** insert a single row into the table: "stripe_subscription" */ @@ -22988,10 +26120,6 @@ export type Mutation_Root = { insert_survey_v2_response_answer_option_one?: Maybe; /** insert a single row into the table: "survey_v2_response" */ insert_survey_v2_response_one?: Maybe; - /** insert data into the table: "tag" */ - insert_tag?: Maybe; - /** insert a single row into the table: "tag" */ - insert_tag_one?: Maybe; /** insert data into the table: "task_event" */ insert_task_event?: Maybe; /** insert a single row into the table: "task_event" */ @@ -23108,7 +26236,6 @@ export type Mutation_Root = { insert_zendesk_support_tickets?: Maybe; /** insert a single row into the table: "zendesk_support_tickets" */ insert_zendesk_support_tickets_one?: Maybe; - insertSchemaRegistryChanges?: Maybe; inviteBillingManager?: Maybe; inviteCollaborator?: Maybe; lastMonthProjectUsage: Array; @@ -23140,6 +26267,8 @@ export type Mutation_Root = { /** Action to save survey question's answer */ saveSurveyAnswerV2?: Maybe; setDefaultPaymentMethod?: Maybe; + /** Action to exchange granted code for access token */ + slackExchangeOAuthToken: SlackExchangeTokenResponse; /** Action to track activity of experiments cohort users */ trackExperimentsCohortActivity?: Maybe; /** Action to track the onboarding activity */ @@ -23168,6 +26297,47 @@ export type Mutation_Root = { triggerRegionModule?: Maybe; triggerRegionMonitoringModule?: Maybe; triggerTaskqModule?: Maybe; + triggerV3CentralModule?: Maybe; + triggerV3ServerModule?: Maybe; + triggerV3SyncModule?: Maybe; + /** update data of the table: "alert_config" */ + update_alert_config?: Maybe; + /** update data of the table: "alert_config_alert_type" */ + update_alert_config_alert_type?: Maybe; + /** update single row of the table: "alert_config_alert_type" */ + update_alert_config_alert_type_by_pk?: Maybe; + /** update multiples rows of table: "alert_config_alert_type" */ + update_alert_config_alert_type_many?: Maybe< + Array> + >; + /** update single row of the table: "alert_config" */ + update_alert_config_by_pk?: Maybe; + /** update multiples rows of table: "alert_config" */ + update_alert_config_many?: Maybe< + Array> + >; + /** update data of the table: "alert_config_service" */ + update_alert_config_service?: Maybe; + /** update single row of the table: "alert_config_service" */ + update_alert_config_service_by_pk?: Maybe; + /** update multiples rows of table: "alert_config_service" */ + update_alert_config_service_many?: Maybe< + Array> + >; + /** update data of the table: "alert_service_type" */ + update_alert_service_type?: Maybe; + /** update single row of the table: "alert_service_type" */ + update_alert_service_type_by_pk?: Maybe; + /** update multiples rows of table: "alert_service_type" */ + update_alert_service_type_many?: Maybe< + Array> + >; + /** update data of the table: "alert_type" */ + update_alert_type?: Maybe; + /** update single row of the table: "alert_type" */ + update_alert_type_by_pk?: Maybe; + /** update multiples rows of table: "alert_type" */ + update_alert_type_many?: Maybe>>; /** update data of the table: "azuremonitor_config" */ update_azuremonitor_config?: Maybe; /** update single row of the table: "azuremonitor_config" */ @@ -23256,6 +26426,22 @@ export type Mutation_Root = { update_config_status_many?: Maybe< Array> >; + /** update data of the table: "connector_config" */ + update_connector_config?: Maybe; + /** update single row of the table: "connector_config" */ + update_connector_config_by_pk?: Maybe; + /** update multiples rows of table: "connector_config" */ + update_connector_config_many?: Maybe< + Array> + >; + /** update data of the table: "connector_deployments" */ + update_connector_deployments?: Maybe; + /** update single row of the table: "connector_deployments" */ + update_connector_deployments_by_pk?: Maybe; + /** update multiples rows of table: "connector_deployments" */ + update_connector_deployments_many?: Maybe< + Array> + >; /** update data of the table: "coupon" */ update_coupon?: Maybe; /** update single row of the table: "coupon" */ @@ -23360,6 +26546,30 @@ export type Mutation_Root = { update_ddn_environment_many?: Maybe< Array> >; + /** update data of the table: "ddn.project_entitlement_access" */ + update_ddn_project_entitlement_access?: Maybe; + /** update single row of the table: "ddn.project_entitlement_access" */ + update_ddn_project_entitlement_access_by_pk?: Maybe; + /** update multiples rows of table: "ddn.project_entitlement_access" */ + update_ddn_project_entitlement_access_many?: Maybe< + Array> + >; + /** update data of the table: "ddn.project_entitlement_catalogue" */ + update_ddn_project_entitlement_catalogue?: Maybe; + /** update single row of the table: "ddn.project_entitlement_catalogue" */ + update_ddn_project_entitlement_catalogue_by_pk?: Maybe; + /** update multiples rows of table: "ddn.project_entitlement_catalogue" */ + update_ddn_project_entitlement_catalogue_many?: Maybe< + Array> + >; + /** update data of the table: "ddn.project_entitlement_types" */ + update_ddn_project_entitlement_types?: Maybe; + /** update single row of the table: "ddn.project_entitlement_types" */ + update_ddn_project_entitlement_types_by_pk?: Maybe; + /** update multiples rows of table: "ddn.project_entitlement_types" */ + update_ddn_project_entitlement_types_many?: Maybe< + Array> + >; /** update data of the table: "ddn.projects" */ update_ddn_projects?: Maybe; /** update single row of the table: "ddn.projects" */ @@ -23386,6 +26596,14 @@ export type Mutation_Root = { update_dedicated_cloud_bills?: Maybe; /** update single row of the table: "dedicated_cloud_bills" */ update_dedicated_cloud_bills_by_pk?: Maybe; + /** update data of the table: "dedicated_cloud_bills_details" */ + update_dedicated_cloud_bills_details?: Maybe; + /** update single row of the table: "dedicated_cloud_bills_details" */ + update_dedicated_cloud_bills_details_by_pk?: Maybe; + /** update multiples rows of table: "dedicated_cloud_bills_details" */ + update_dedicated_cloud_bills_details_many?: Maybe< + Array> + >; /** update multiples rows of table: "dedicated_cloud_bills" */ update_dedicated_cloud_bills_many?: Maybe< Array> @@ -23562,14 +26780,6 @@ export type Mutation_Root = { update_hasura_cluster_many?: Maybe< Array> >; - /** update data of the table: "hasura_graphql_schema_tags" */ - update_hasura_graphql_schema_tags?: Maybe; - /** update single row of the table: "hasura_graphql_schema_tags" */ - update_hasura_graphql_schema_tags_by_pk?: Maybe; - /** update multiples rows of table: "hasura_graphql_schema_tags" */ - update_hasura_graphql_schema_tags_many?: Maybe< - Array> - >; /** update data of the table: "hasura_worker" */ update_hasura_worker?: Maybe; /** update single row of the table: "hasura_worker" */ @@ -24134,28 +27344,20 @@ export type Mutation_Root = { update_saml_idp_by_pk?: Maybe; /** update multiples rows of table: "saml_idp" */ update_saml_idp_many?: Maybe>>; - /** update data of the table: "schema_diff_data" */ - update_schema_diff_data?: Maybe; - /** update single row of the table: "schema_diff_data" */ - update_schema_diff_data_by_pk?: Maybe; - /** update multiples rows of table: "schema_diff_data" */ - update_schema_diff_data_many?: Maybe< - Array> - >; - /** update data of the table: "schema_registry_dumps" */ - update_schema_registry_dumps?: Maybe; - /** update single row of the table: "schema_registry_dumps" */ - update_schema_registry_dumps_by_pk?: Maybe; - /** update multiples rows of table: "schema_registry_dumps" */ - update_schema_registry_dumps_many?: Maybe< - Array> - >; /** update data of the table: "search_project_login_status_results" */ update_search_project_login_status_results?: Maybe; /** update multiples rows of table: "search_project_login_status_results" */ update_search_project_login_status_results_many?: Maybe< Array> >; + /** update data of the table: "slack_config" */ + update_slack_config?: Maybe; + /** update single row of the table: "slack_config" */ + update_slack_config_by_pk?: Maybe; + /** update multiples rows of table: "slack_config" */ + update_slack_config_many?: Maybe< + Array> + >; /** update data of the table: "stripe_subscription" */ update_stripe_subscription?: Maybe; /** update single row of the table: "stripe_subscription" */ @@ -24298,12 +27500,6 @@ export type Mutation_Root = { update_survey_v2_response_many?: Maybe< Array> >; - /** update data of the table: "tag" */ - update_tag?: Maybe; - /** update single row of the table: "tag" */ - update_tag_by_pk?: Maybe; - /** update multiples rows of table: "tag" */ - update_tag_many?: Maybe>>; /** update data of the table: "task_event" */ update_task_event?: Maybe; /** update single row of the table: "task_event" */ @@ -24652,6 +27848,45 @@ export type Mutation_RootCompleteChangeUserEmailRequestArgs = { input: ChangeUserEmailRequestKeyInput; }; +/** mutation root */ +export type Mutation_RootConnector_Delete_Connector_DeploymentArgs = { + where: Connector_Connector_Deployment_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootConnector_Delete_Connector_Deployment_By_PkArgs = { + id: Scalars['connector_uuid']; +}; + +/** mutation root */ +export type Mutation_RootConnector_Insert_Connector_DeploymentArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootConnector_Insert_Connector_Deployment_OneArgs = { + object: Connector_Connector_Deployment_Insert_Input; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootConnector_Update_Connector_DeploymentArgs = { + _set?: Maybe; + where: Connector_Connector_Deployment_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootConnector_Update_Connector_Deployment_By_PkArgs = { + _set?: Maybe; + pk_columns: Connector_Connector_Deployment_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootConnector_Update_Connector_Deployment_ManyArgs = { + updates: Array; +}; + /** mutation root */ export type Mutation_RootConvertToDedicatedCloudArgs = { projectId: Scalars['uuid']; @@ -24723,6 +27958,7 @@ export type Mutation_RootDdnApplyMetadataArgs = { /** mutation root */ export type Mutation_RootDdnCreateBuildArgs = { + description?: Maybe; metadata_json: Scalars['String']; project_id: Scalars['String']; }; @@ -24763,6 +27999,58 @@ export type Mutation_RootDeclineTransferOwnershipInviteArgs = { inviteKey: Scalars['String']; }; +/** mutation root */ +export type Mutation_RootDelete_Alert_ConfigArgs = { + where: Alert_Config_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Alert_Config_Alert_TypeArgs = { + where: Alert_Config_Alert_Type_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Alert_Config_Alert_Type_By_PkArgs = { + project_id: Scalars['uuid']; + type: Scalars['String']; +}; + +/** mutation root */ +export type Mutation_RootDelete_Alert_Config_By_PkArgs = { + project_id: Scalars['uuid']; +}; + +/** mutation root */ +export type Mutation_RootDelete_Alert_Config_ServiceArgs = { + where: Alert_Config_Service_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Alert_Config_Service_By_PkArgs = { + project_id: Scalars['uuid']; + type: Alert_Service_Type_Enum; +}; + +/** mutation root */ +export type Mutation_RootDelete_Alert_Service_TypeArgs = { + where: Alert_Service_Type_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Alert_Service_Type_By_PkArgs = { + name: Scalars['String']; +}; + +/** mutation root */ +export type Mutation_RootDelete_Alert_TypeArgs = { + where: Alert_Type_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Alert_Type_By_PkArgs = { + id: Scalars['String']; +}; + /** mutation root */ export type Mutation_RootDelete_Azuremonitor_ConfigArgs = { where: Azuremonitor_Config_Bool_Exp; @@ -24875,6 +28163,26 @@ export type Mutation_RootDelete_Config_Status_By_PkArgs = { worker_id: Scalars['uuid']; }; +/** mutation root */ +export type Mutation_RootDelete_Connector_ConfigArgs = { + where: Connector_Config_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Connector_Config_By_PkArgs = { + id: Scalars['uuid']; +}; + +/** mutation root */ +export type Mutation_RootDelete_Connector_DeploymentsArgs = { + where: Connector_Deployments_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Connector_Deployments_By_PkArgs = { + id: Scalars['uuid']; +}; + /** mutation root */ export type Mutation_RootDelete_CouponArgs = { where: Coupon_Bool_Exp; @@ -25015,6 +28323,36 @@ export type Mutation_RootDelete_Ddn_Environment_By_PkArgs = { id: Scalars['uuid']; }; +/** mutation root */ +export type Mutation_RootDelete_Ddn_Project_Entitlement_AccessArgs = { + where: Ddn_Project_Entitlement_Access_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Ddn_Project_Entitlement_Access_By_PkArgs = { + id: Scalars['uuid']; +}; + +/** mutation root */ +export type Mutation_RootDelete_Ddn_Project_Entitlement_CatalogueArgs = { + where: Ddn_Project_Entitlement_Catalogue_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Ddn_Project_Entitlement_Catalogue_By_PkArgs = { + id: Scalars['uuid']; +}; + +/** mutation root */ +export type Mutation_RootDelete_Ddn_Project_Entitlement_TypesArgs = { + where: Ddn_Project_Entitlement_Types_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Ddn_Project_Entitlement_Types_By_PkArgs = { + value: Scalars['String']; +}; + /** mutation root */ export type Mutation_RootDelete_Ddn_ProjectsArgs = { where: Ddn_Projects_Bool_Exp; @@ -25055,6 +28393,16 @@ export type Mutation_RootDelete_Dedicated_Cloud_Bills_By_PkArgs = { id: Scalars['uuid']; }; +/** mutation root */ +export type Mutation_RootDelete_Dedicated_Cloud_Bills_DetailsArgs = { + where: Dedicated_Cloud_Bills_Details_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Dedicated_Cloud_Bills_Details_By_PkArgs = { + id: Scalars['uuid']; +}; + /** mutation root */ export type Mutation_RootDelete_Dedicated_Cloud_CommitmentsArgs = { where: Dedicated_Cloud_Commitments_Bool_Exp; @@ -25292,16 +28640,6 @@ export type Mutation_RootDelete_Hasura_Cluster_By_PkArgs = { id: Scalars['uuid']; }; -/** mutation root */ -export type Mutation_RootDelete_Hasura_Graphql_Schema_TagsArgs = { - where: Hasura_Graphql_Schema_Tags_Bool_Exp; -}; - -/** mutation root */ -export type Mutation_RootDelete_Hasura_Graphql_Schema_Tags_By_PkArgs = { - id: Scalars['uuid']; -}; - /** mutation root */ export type Mutation_RootDelete_Hasura_WorkerArgs = { where: Hasura_Worker_Bool_Exp; @@ -26043,31 +29381,21 @@ export type Mutation_RootDelete_Saml_Idp_By_PkArgs = { id: Scalars['uuid']; }; -/** mutation root */ -export type Mutation_RootDelete_Schema_Diff_DataArgs = { - where: Schema_Diff_Data_Bool_Exp; -}; - -/** mutation root */ -export type Mutation_RootDelete_Schema_Diff_Data_By_PkArgs = { - id: Scalars['uuid']; -}; - -/** mutation root */ -export type Mutation_RootDelete_Schema_Registry_DumpsArgs = { - where: Schema_Registry_Dumps_Bool_Exp; -}; - -/** mutation root */ -export type Mutation_RootDelete_Schema_Registry_Dumps_By_PkArgs = { - id: Scalars['uuid']; -}; - /** mutation root */ export type Mutation_RootDelete_Search_Project_Login_Status_ResultsArgs = { where: Search_Project_Login_Status_Results_Bool_Exp; }; +/** mutation root */ +export type Mutation_RootDelete_Slack_ConfigArgs = { + where: Slack_Config_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootDelete_Slack_Config_By_PkArgs = { + id: Scalars['uuid']; +}; + /** mutation root */ export type Mutation_RootDelete_Stripe_SubscriptionArgs = { where: Stripe_Subscription_Bool_Exp; @@ -26251,16 +29579,6 @@ export type Mutation_RootDelete_Survey_V2_Response_By_PkArgs = { id: Scalars['uuid']; }; -/** mutation root */ -export type Mutation_RootDelete_TagArgs = { - where: Tag_Bool_Exp; -}; - -/** mutation root */ -export type Mutation_RootDelete_Tag_By_PkArgs = { - id: Scalars['uuid']; -}; - /** mutation root */ export type Mutation_RootDelete_Task_EventArgs = { where: Task_Event_Bool_Exp; @@ -26559,6 +29877,11 @@ export type Mutation_RootDeleteProjectArgs = { project: DeleteProjectInput; }; +/** mutation root */ +export type Mutation_RootDeleteSlackAppArgs = { + args: DelteSlackAppPayload; +}; + /** mutation root */ export type Mutation_RootDeleteTenantArgs = { tenantId: Scalars['uuid']; @@ -26581,13 +29904,6 @@ export type Mutation_RootEnableCloudflareProxyArgs = { tenant_id: Scalars['uuid']; }; -/** mutation root */ -export type Mutation_RootFetchDedicatedCloudClusterBillsArgs = { - month: Scalars['Int']; - user_id: Scalars['uuid']; - year: Scalars['Int']; -}; - /** mutation root */ export type Mutation_RootGetGithubSessionArgs = { project_id: Scalars['uuid']; @@ -26631,6 +29947,66 @@ export type Mutation_RootHerokuUnregisterWebhookVarArgs = { varName: Scalars['String']; }; +/** mutation root */ +export type Mutation_RootInsert_Alert_ConfigArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Alert_Config_Alert_TypeArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Alert_Config_Alert_Type_OneArgs = { + object: Alert_Config_Alert_Type_Insert_Input; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Alert_Config_OneArgs = { + object: Alert_Config_Insert_Input; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Alert_Config_ServiceArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Alert_Config_Service_OneArgs = { + object: Alert_Config_Service_Insert_Input; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Alert_Service_TypeArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Alert_Service_Type_OneArgs = { + object: Alert_Service_Type_Insert_Input; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Alert_TypeArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Alert_Type_OneArgs = { + object: Alert_Type_Insert_Input; + on_conflict?: Maybe; +}; + /** mutation root */ export type Mutation_RootInsert_Azuremonitor_ConfigArgs = { objects: Array; @@ -26771,6 +30147,30 @@ export type Mutation_RootInsert_Config_Status_OneArgs = { on_conflict?: Maybe; }; +/** mutation root */ +export type Mutation_RootInsert_Connector_ConfigArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Connector_Config_OneArgs = { + object: Connector_Config_Insert_Input; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Connector_DeploymentsArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Connector_Deployments_OneArgs = { + object: Connector_Deployments_Insert_Input; + on_conflict?: Maybe; +}; + /** mutation root */ export type Mutation_RootInsert_CouponArgs = { objects: Array; @@ -26949,6 +30349,42 @@ export type Mutation_RootInsert_Ddn_Environment_OneArgs = { on_conflict?: Maybe; }; +/** mutation root */ +export type Mutation_RootInsert_Ddn_Project_Entitlement_AccessArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Ddn_Project_Entitlement_Access_OneArgs = { + object: Ddn_Project_Entitlement_Access_Insert_Input; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Ddn_Project_Entitlement_CatalogueArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Ddn_Project_Entitlement_Catalogue_OneArgs = { + object: Ddn_Project_Entitlement_Catalogue_Insert_Input; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Ddn_Project_Entitlement_TypesArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Ddn_Project_Entitlement_Types_OneArgs = { + object: Ddn_Project_Entitlement_Types_Insert_Input; + on_conflict?: Maybe; +}; + /** mutation root */ export type Mutation_RootInsert_Ddn_ProjectsArgs = { objects: Array; @@ -26991,6 +30427,18 @@ export type Mutation_RootInsert_Dedicated_Cloud_BillsArgs = { on_conflict?: Maybe; }; +/** mutation root */ +export type Mutation_RootInsert_Dedicated_Cloud_Bills_DetailsArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Dedicated_Cloud_Bills_Details_OneArgs = { + object: Dedicated_Cloud_Bills_Details_Insert_Input; + on_conflict?: Maybe; +}; + /** mutation root */ export type Mutation_RootInsert_Dedicated_Cloud_Bills_OneArgs = { object: Dedicated_Cloud_Bills_Insert_Input; @@ -27273,18 +30721,6 @@ export type Mutation_RootInsert_Hasura_Cluster_OneArgs = { on_conflict?: Maybe; }; -/** mutation root */ -export type Mutation_RootInsert_Hasura_Graphql_Schema_TagsArgs = { - objects: Array; - on_conflict?: Maybe; -}; - -/** mutation root */ -export type Mutation_RootInsert_Hasura_Graphql_Schema_Tags_OneArgs = { - object: Hasura_Graphql_Schema_Tags_Insert_Input; - on_conflict?: Maybe; -}; - /** mutation root */ export type Mutation_RootInsert_Hasura_WorkerArgs = { objects: Array; @@ -28187,30 +31623,6 @@ export type Mutation_RootInsert_Saml_Idp_OneArgs = { on_conflict?: Maybe; }; -/** mutation root */ -export type Mutation_RootInsert_Schema_Diff_DataArgs = { - objects: Array; - on_conflict?: Maybe; -}; - -/** mutation root */ -export type Mutation_RootInsert_Schema_Diff_Data_OneArgs = { - object: Schema_Diff_Data_Insert_Input; - on_conflict?: Maybe; -}; - -/** mutation root */ -export type Mutation_RootInsert_Schema_Registry_DumpsArgs = { - objects: Array; - on_conflict?: Maybe; -}; - -/** mutation root */ -export type Mutation_RootInsert_Schema_Registry_Dumps_OneArgs = { - object: Schema_Registry_Dumps_Insert_Input; - on_conflict?: Maybe; -}; - /** mutation root */ export type Mutation_RootInsert_Search_Project_Login_Status_ResultsArgs = { objects: Array; @@ -28221,6 +31633,18 @@ export type Mutation_RootInsert_Search_Project_Login_Status_Results_OneArgs = { object: Search_Project_Login_Status_Results_Insert_Input; }; +/** mutation root */ +export type Mutation_RootInsert_Slack_ConfigArgs = { + objects: Array; + on_conflict?: Maybe; +}; + +/** mutation root */ +export type Mutation_RootInsert_Slack_Config_OneArgs = { + object: Slack_Config_Insert_Input; + on_conflict?: Maybe; +}; + /** mutation root */ export type Mutation_RootInsert_Stripe_SubscriptionArgs = { objects: Array; @@ -28439,18 +31863,6 @@ export type Mutation_RootInsert_Survey_V2_Response_OneArgs = { on_conflict?: Maybe; }; -/** mutation root */ -export type Mutation_RootInsert_TagArgs = { - objects: Array; - on_conflict?: Maybe; -}; - -/** mutation root */ -export type Mutation_RootInsert_Tag_OneArgs = { - object: Tag_Insert_Input; - on_conflict?: Maybe; -}; - /** mutation root */ export type Mutation_RootInsert_Task_EventArgs = { objects: Array; @@ -28797,11 +32209,6 @@ export type Mutation_RootInsert_Zendesk_Support_Tickets_OneArgs = { on_conflict?: Maybe; }; -/** mutation root */ -export type Mutation_RootInsertSchemaRegistryChangesArgs = { - changes: Insert_Schema_Registry_Changes_Input; -}; - /** mutation root */ export type Mutation_RootInviteBillingManagerArgs = { manager_email: Scalars['String']; @@ -28920,6 +32327,12 @@ export type Mutation_RootSetDefaultPaymentMethodArgs = { id: Scalars['String']; }; +/** mutation root */ +export type Mutation_RootSlackExchangeOAuthTokenArgs = { + code: Scalars['String']; + projectId: Scalars['uuid']; +}; + /** mutation root */ export type Mutation_RootTrackExperimentsCohortActivityArgs = { experiment: Scalars['String']; @@ -28955,7 +32368,7 @@ export type Mutation_RootTriggerAnalyticsInfraModuleArgs = { /** mutation root */ export type Mutation_RootTriggerCentralModuleArgs = { branch?: Maybe; - cloud: Scalars['String']; + cloud: CloudProvider; commit?: Maybe; mode: PulumiMode; targets?: Maybe>>; @@ -29065,7 +32478,7 @@ export type Mutation_RootTriggerLogsModuleArgs = { /** mutation root */ export type Mutation_RootTriggerLuxProxyModuleArgs = { branch?: Maybe; - cloud: Scalars['String']; + cloud: CloudProvider; commit?: Maybe; mode: PulumiMode; region: Scalars['String']; @@ -29136,6 +32549,130 @@ export type Mutation_RootTriggerTaskqModuleArgs = { targets?: Maybe>>; }; +/** mutation root */ +export type Mutation_RootTriggerV3CentralModuleArgs = { + branch?: Maybe; + cloud: CloudProvider; + commit?: Maybe; + mode: PulumiMode; + targets?: Maybe>>; +}; + +/** mutation root */ +export type Mutation_RootTriggerV3ServerModuleArgs = { + branch?: Maybe; + cloud: CloudProvider; + commit?: Maybe; + mode: PulumiMode; + region: Scalars['String']; + targets?: Maybe>>; +}; + +/** mutation root */ +export type Mutation_RootTriggerV3SyncModuleArgs = { + branch?: Maybe; + cloud: CloudProvider; + commit?: Maybe; + mode: PulumiMode; + region: Scalars['String']; + targets?: Maybe>>; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_ConfigArgs = { + _set?: Maybe; + where: Alert_Config_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Config_Alert_TypeArgs = { + _set?: Maybe; + where: Alert_Config_Alert_Type_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Config_Alert_Type_By_PkArgs = { + _set?: Maybe; + pk_columns: Alert_Config_Alert_Type_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Config_Alert_Type_ManyArgs = { + updates: Array; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Config_By_PkArgs = { + _set?: Maybe; + pk_columns: Alert_Config_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Config_ManyArgs = { + updates: Array; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Config_ServiceArgs = { + _append?: Maybe; + _delete_at_path?: Maybe; + _delete_elem?: Maybe; + _delete_key?: Maybe; + _prepend?: Maybe; + _set?: Maybe; + where: Alert_Config_Service_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Config_Service_By_PkArgs = { + _append?: Maybe; + _delete_at_path?: Maybe; + _delete_elem?: Maybe; + _delete_key?: Maybe; + _prepend?: Maybe; + _set?: Maybe; + pk_columns: Alert_Config_Service_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Config_Service_ManyArgs = { + updates: Array; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Service_TypeArgs = { + _set?: Maybe; + where: Alert_Service_Type_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Service_Type_By_PkArgs = { + _set?: Maybe; + pk_columns: Alert_Service_Type_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Service_Type_ManyArgs = { + updates: Array; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_TypeArgs = { + _set?: Maybe; + where: Alert_Type_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Type_By_PkArgs = { + _set?: Maybe; + pk_columns: Alert_Type_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Alert_Type_ManyArgs = { + updates: Array; +}; + /** mutation root */ export type Mutation_RootUpdate_Azuremonitor_ConfigArgs = { _append?: Maybe; @@ -29372,6 +32909,40 @@ export type Mutation_RootUpdate_Config_Status_ManyArgs = { updates: Array; }; +/** mutation root */ +export type Mutation_RootUpdate_Connector_ConfigArgs = { + _set?: Maybe; + where: Connector_Config_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Connector_Config_By_PkArgs = { + _set?: Maybe; + pk_columns: Connector_Config_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Connector_Config_ManyArgs = { + updates: Array; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Connector_DeploymentsArgs = { + _set?: Maybe; + where: Connector_Deployments_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Connector_Deployments_By_PkArgs = { + _set?: Maybe; + pk_columns: Connector_Deployments_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Connector_Deployments_ManyArgs = { + updates: Array; +}; + /** mutation root */ export type Mutation_RootUpdate_CouponArgs = { _append?: Maybe; @@ -29572,12 +33143,22 @@ export type Mutation_RootUpdate_Db_Latency_ManyArgs = { /** mutation root */ export type Mutation_RootUpdate_Ddn_BuildArgs = { + _append?: Maybe; + _delete_at_path?: Maybe; + _delete_elem?: Maybe; + _delete_key?: Maybe; + _prepend?: Maybe; _set?: Maybe; where: Ddn_Build_Bool_Exp; }; /** mutation root */ export type Mutation_RootUpdate_Ddn_Build_By_PkArgs = { + _append?: Maybe; + _delete_at_path?: Maybe; + _delete_elem?: Maybe; + _delete_key?: Maybe; + _prepend?: Maybe; _set?: Maybe; pk_columns: Ddn_Build_Pk_Columns_Input; }; @@ -29638,6 +33219,59 @@ export type Mutation_RootUpdate_Ddn_Environment_ManyArgs = { updates: Array; }; +/** mutation root */ +export type Mutation_RootUpdate_Ddn_Project_Entitlement_AccessArgs = { + _set?: Maybe; + where: Ddn_Project_Entitlement_Access_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Ddn_Project_Entitlement_Access_By_PkArgs = { + _set?: Maybe; + pk_columns: Ddn_Project_Entitlement_Access_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Ddn_Project_Entitlement_Access_ManyArgs = { + updates: Array; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Ddn_Project_Entitlement_CatalogueArgs = { + _inc?: Maybe; + _set?: Maybe; + where: Ddn_Project_Entitlement_Catalogue_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Ddn_Project_Entitlement_Catalogue_By_PkArgs = { + _inc?: Maybe; + _set?: Maybe; + pk_columns: Ddn_Project_Entitlement_Catalogue_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Ddn_Project_Entitlement_Catalogue_ManyArgs = { + updates: Array; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Ddn_Project_Entitlement_TypesArgs = { + _set?: Maybe; + where: Ddn_Project_Entitlement_Types_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Ddn_Project_Entitlement_Types_By_PkArgs = { + _set?: Maybe; + pk_columns: Ddn_Project_Entitlement_Types_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Ddn_Project_Entitlement_Types_ManyArgs = { + updates: Array; +}; + /** mutation root */ export type Mutation_RootUpdate_Ddn_ProjectsArgs = { _set?: Maybe; @@ -29715,6 +33349,35 @@ export type Mutation_RootUpdate_Dedicated_Cloud_Bills_By_PkArgs = { pk_columns: Dedicated_Cloud_Bills_Pk_Columns_Input; }; +/** mutation root */ +export type Mutation_RootUpdate_Dedicated_Cloud_Bills_DetailsArgs = { + _append?: Maybe; + _delete_at_path?: Maybe; + _delete_elem?: Maybe; + _delete_key?: Maybe; + _inc?: Maybe; + _prepend?: Maybe; + _set?: Maybe; + where: Dedicated_Cloud_Bills_Details_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Dedicated_Cloud_Bills_Details_By_PkArgs = { + _append?: Maybe; + _delete_at_path?: Maybe; + _delete_elem?: Maybe; + _delete_key?: Maybe; + _inc?: Maybe; + _prepend?: Maybe; + _set?: Maybe; + pk_columns: Dedicated_Cloud_Bills_Details_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Dedicated_Cloud_Bills_Details_ManyArgs = { + updates: Array; +}; + /** mutation root */ export type Mutation_RootUpdate_Dedicated_Cloud_Bills_ManyArgs = { updates: Array; @@ -30227,23 +33890,6 @@ export type Mutation_RootUpdate_Hasura_Cluster_ManyArgs = { updates: Array; }; -/** mutation root */ -export type Mutation_RootUpdate_Hasura_Graphql_Schema_TagsArgs = { - _set?: Maybe; - where: Hasura_Graphql_Schema_Tags_Bool_Exp; -}; - -/** mutation root */ -export type Mutation_RootUpdate_Hasura_Graphql_Schema_Tags_By_PkArgs = { - _set?: Maybe; - pk_columns: Hasura_Graphql_Schema_Tags_Pk_Columns_Input; -}; - -/** mutation root */ -export type Mutation_RootUpdate_Hasura_Graphql_Schema_Tags_ManyArgs = { - updates: Array; -}; - /** mutation root */ export type Mutation_RootUpdate_Hasura_WorkerArgs = { _set?: Maybe; @@ -31727,52 +35373,6 @@ export type Mutation_RootUpdate_Saml_Idp_ManyArgs = { updates: Array; }; -/** mutation root */ -export type Mutation_RootUpdate_Schema_Diff_DataArgs = { - _append?: Maybe; - _delete_at_path?: Maybe; - _delete_elem?: Maybe; - _delete_key?: Maybe; - _prepend?: Maybe; - _set?: Maybe; - where: Schema_Diff_Data_Bool_Exp; -}; - -/** mutation root */ -export type Mutation_RootUpdate_Schema_Diff_Data_By_PkArgs = { - _append?: Maybe; - _delete_at_path?: Maybe; - _delete_elem?: Maybe; - _delete_key?: Maybe; - _prepend?: Maybe; - _set?: Maybe; - pk_columns: Schema_Diff_Data_Pk_Columns_Input; -}; - -/** mutation root */ -export type Mutation_RootUpdate_Schema_Diff_Data_ManyArgs = { - updates: Array; -}; - -/** mutation root */ -export type Mutation_RootUpdate_Schema_Registry_DumpsArgs = { - _inc?: Maybe; - _set?: Maybe; - where: Schema_Registry_Dumps_Bool_Exp; -}; - -/** mutation root */ -export type Mutation_RootUpdate_Schema_Registry_Dumps_By_PkArgs = { - _inc?: Maybe; - _set?: Maybe; - pk_columns: Schema_Registry_Dumps_Pk_Columns_Input; -}; - -/** mutation root */ -export type Mutation_RootUpdate_Schema_Registry_Dumps_ManyArgs = { - updates: Array; -}; - /** mutation root */ export type Mutation_RootUpdate_Search_Project_Login_Status_ResultsArgs = { _inc?: Maybe; @@ -31785,6 +35385,23 @@ export type Mutation_RootUpdate_Search_Project_Login_Status_Results_ManyArgs = { updates: Array; }; +/** mutation root */ +export type Mutation_RootUpdate_Slack_ConfigArgs = { + _set?: Maybe; + where: Slack_Config_Bool_Exp; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Slack_Config_By_PkArgs = { + _set?: Maybe; + pk_columns: Slack_Config_Pk_Columns_Input; +}; + +/** mutation root */ +export type Mutation_RootUpdate_Slack_Config_ManyArgs = { + updates: Array; +}; + /** mutation root */ export type Mutation_RootUpdate_Stripe_SubscriptionArgs = { _set?: Maybe; @@ -32138,23 +35755,6 @@ export type Mutation_RootUpdate_Survey_V2_Response_ManyArgs = { updates: Array; }; -/** mutation root */ -export type Mutation_RootUpdate_TagArgs = { - _set?: Maybe; - where: Tag_Bool_Exp; -}; - -/** mutation root */ -export type Mutation_RootUpdate_Tag_By_PkArgs = { - _set?: Maybe; - pk_columns: Tag_Pk_Columns_Input; -}; - -/** mutation root */ -export type Mutation_RootUpdate_Tag_ManyArgs = { - updates: Array; -}; - /** mutation root */ export type Mutation_RootUpdate_Task_EventArgs = { _append?: Maybe; @@ -37693,6 +41293,7 @@ export type Plans = { created_at: Scalars['timestamptz']; description: Scalars['String']; enable_granular_metrics?: Maybe; + enable_otel_exporter: Scalars['Boolean']; /** An array relationship */ entitlements: Array; /** An aggregate relationship */ @@ -37798,6 +41399,7 @@ export type Plans_Bool_Exp = { created_at?: Maybe; description?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; entitlements?: Maybe; entitlements_aggregate?: Maybe; high_availability_enabled?: Maybe; @@ -37856,6 +41458,7 @@ export type Plans_Insert_Input = { created_at?: Maybe; description?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; entitlements?: Maybe; high_availability_enabled?: Maybe; log_retention?: Maybe; @@ -37957,6 +41560,7 @@ export type Plans_Order_By = { created_at?: Maybe; description?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; entitlements_aggregate?: Maybe; high_availability_enabled?: Maybe; log_retention?: Maybe; @@ -38008,6 +41612,8 @@ export enum Plans_Select_Column { /** column name */ EnableGranularMetrics = 'enable_granular_metrics', /** column name */ + EnableOtelExporter = 'enable_otel_exporter', + /** column name */ HighAvailabilityEnabled = 'high_availability_enabled', /** column name */ LogRetention = 'log_retention', @@ -38058,6 +41664,7 @@ export type Plans_Set_Input = { created_at?: Maybe; description?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; high_availability_enabled?: Maybe; log_retention?: Maybe; max_api_limit_roles?: Maybe; @@ -38153,6 +41760,7 @@ export type Plans_Stream_Cursor_Value_Input = { created_at?: Maybe; description?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; high_availability_enabled?: Maybe; log_retention?: Maybe; max_api_limit_roles?: Maybe; @@ -38216,6 +41824,8 @@ export enum Plans_Update_Column { /** column name */ EnableGranularMetrics = 'enable_granular_metrics', /** column name */ + EnableOtelExporter = 'enable_otel_exporter', + /** column name */ HighAvailabilityEnabled = 'high_availability_enabled', /** column name */ LogRetention = 'log_retention', @@ -38329,6 +41939,7 @@ export type Policies = { collaborators_enabled: Scalars['Boolean']; created_at: Scalars['timestamptz']; enable_granular_metrics?: Maybe; + enable_otel_exporter: Scalars['Boolean']; high_availability_enabled: Scalars['Boolean']; log_retention: Scalars['Int']; max_api_limit_roles?: Maybe; @@ -38479,6 +42090,7 @@ export type Policies_Bool_Exp = { collaborators_enabled?: Maybe; created_at?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; high_availability_enabled?: Maybe; log_retention?: Maybe; max_api_limit_roles?: Maybe; @@ -38535,6 +42147,7 @@ export type Policies_Insert_Input = { collaborators_enabled?: Maybe; created_at?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; high_availability_enabled?: Maybe; log_retention?: Maybe; max_api_limit_roles?: Maybe; @@ -38673,6 +42286,7 @@ export type Policies_Order_By = { collaborators_enabled?: Maybe; created_at?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; high_availability_enabled?: Maybe; log_retention?: Maybe; max_api_limit_roles?: Maybe; @@ -38722,6 +42336,8 @@ export enum Policies_Select_Column { /** column name */ EnableGranularMetrics = 'enable_granular_metrics', /** column name */ + EnableOtelExporter = 'enable_otel_exporter', + /** column name */ HighAvailabilityEnabled = 'high_availability_enabled', /** column name */ LogRetention = 'log_retention', @@ -38774,6 +42390,8 @@ export enum Policies_Select_Column_Policies_Aggregate_Bool_Exp_Bool_And_Argument /** column name */ EnableGranularMetrics = 'enable_granular_metrics', /** column name */ + EnableOtelExporter = 'enable_otel_exporter', + /** column name */ HighAvailabilityEnabled = 'high_availability_enabled', /** column name */ MetricsEnabled = 'metrics_enabled', @@ -38802,6 +42420,8 @@ export enum Policies_Select_Column_Policies_Aggregate_Bool_Exp_Bool_Or_Arguments /** column name */ EnableGranularMetrics = 'enable_granular_metrics', /** column name */ + EnableOtelExporter = 'enable_otel_exporter', + /** column name */ HighAvailabilityEnabled = 'high_availability_enabled', /** column name */ MetricsEnabled = 'metrics_enabled', @@ -38827,6 +42447,7 @@ export type Policies_Set_Input = { collaborators_enabled?: Maybe; created_at?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; high_availability_enabled?: Maybe; log_retention?: Maybe; max_api_limit_roles?: Maybe; @@ -38972,6 +42593,7 @@ export type Policies_Stream_Cursor_Value_Input = { collaborators_enabled?: Maybe; created_at?: Maybe; enable_granular_metrics?: Maybe; + enable_otel_exporter?: Maybe; high_availability_enabled?: Maybe; log_retention?: Maybe; max_api_limit_roles?: Maybe; @@ -39050,6 +42672,8 @@ export enum Policies_Update_Column { /** column name */ EnableGranularMetrics = 'enable_granular_metrics', /** column name */ + EnableOtelExporter = 'enable_otel_exporter', + /** column name */ HighAvailabilityEnabled = 'high_availability_enabled', /** column name */ LogRetention = 'log_retention', @@ -44507,7 +48131,11 @@ export type Project_Db_Usage_Variance_Fields = { price?: Maybe; }; -/** Each entry in this table represents entitlements a project has access to. */ +/** + * Each entry in this table represents a specific project entitlement from + * project_entitlement_catalogue that a project has access to. A project can only + * have one version of a given type of entitlement at a time. + */ export type Project_Entitlement_Access = { __typename?: 'project_entitlement_access'; created_at: Scalars['timestamp']; @@ -47633,6 +51261,8 @@ export type Projects = { activities: Array; /** An aggregate relationship */ activities_aggregate: Project_Activity_Aggregate; + /** An object relationship */ + alert_config?: Maybe; assigned_at?: Maybe; /** An object relationship */ azuremonitor_config?: Maybe; @@ -48066,6 +51696,7 @@ export type Projects_Bool_Exp = { _or?: Maybe>; activities?: Maybe; activities_aggregate?: Maybe; + alert_config?: Maybe; assigned_at?: Maybe; azuremonitor_config?: Maybe; billing_manager?: Maybe; @@ -48136,6 +51767,7 @@ export enum Projects_Constraint { /** input type for inserting data into table "projects" */ export type Projects_Insert_Input = { activities?: Maybe; + alert_config?: Maybe; assigned_at?: Maybe; azuremonitor_config?: Maybe; billing_manager?: Maybe; @@ -48262,6 +51894,7 @@ export type Projects_On_Conflict = { /** Ordering options when selecting data from "projects". */ export type Projects_Order_By = { activities_aggregate?: Maybe; + alert_config?: Maybe; assigned_at?: Maybe; azuremonitor_config?: Maybe; billing_manager?: Maybe; @@ -49926,6 +53559,36 @@ export enum PulumiMode { export type Query_Root = { __typename?: 'query_root'; + /** fetch data from the table: "alert_config" */ + alert_config: Array; + /** fetch aggregated fields from the table: "alert_config" */ + alert_config_aggregate: Alert_Config_Aggregate; + /** fetch data from the table: "alert_config_alert_type" */ + alert_config_alert_type: Array; + /** fetch aggregated fields from the table: "alert_config_alert_type" */ + alert_config_alert_type_aggregate: Alert_Config_Alert_Type_Aggregate; + /** fetch data from the table: "alert_config_alert_type" using primary key columns */ + alert_config_alert_type_by_pk?: Maybe; + /** fetch data from the table: "alert_config" using primary key columns */ + alert_config_by_pk?: Maybe; + /** fetch data from the table: "alert_config_service" */ + alert_config_service: Array; + /** fetch aggregated fields from the table: "alert_config_service" */ + alert_config_service_aggregate: Alert_Config_Service_Aggregate; + /** fetch data from the table: "alert_config_service" using primary key columns */ + alert_config_service_by_pk?: Maybe; + /** fetch data from the table: "alert_service_type" */ + alert_service_type: Array; + /** fetch aggregated fields from the table: "alert_service_type" */ + alert_service_type_aggregate: Alert_Service_Type_Aggregate; + /** fetch data from the table: "alert_service_type" using primary key columns */ + alert_service_type_by_pk?: Maybe; + /** fetch data from the table: "alert_type" */ + alert_type: Array; + /** fetch aggregated fields from the table: "alert_type" */ + alert_type_aggregate: Alert_Type_Aggregate; + /** fetch data from the table: "alert_type" using primary key columns */ + alert_type_by_pk?: Maybe; /** fetch data from the table: "azuremonitor_config" */ azuremonitor_config: Array; /** fetch aggregated fields from the table: "azuremonitor_config" */ @@ -49983,6 +53646,10 @@ export type Query_Root = { cloud_metadata_aggregate: Cloud_Metadata_Aggregate; /** fetch data from the table: "cloud_metadata" using primary key columns */ cloud_metadata_by_pk?: Maybe; + /** fetch data from the table: "cloud_regions_by_plan" */ + cloud_regions_by_plan: Array; + /** fetch aggregated fields from the table: "cloud_regions_by_plan" */ + cloud_regions_by_plan_aggregate: Cloud_Regions_By_Plan_Aggregate; /** execute function "compute_project_agg_db_usage_user" which returns "project_db_usage_agg_user" */ compute_project_agg_db_usage_user: Array; /** @@ -50033,6 +53700,24 @@ export type Query_Root = { config_status_aggregate: Config_Status_Aggregate; /** fetch data from the table: "config_status" using primary key columns */ config_status_by_pk?: Maybe; + /** fetch data from the table: "connector_config" */ + connector_config: Array; + /** fetch aggregated fields from the table: "connector_config" */ + connector_config_aggregate: Connector_Config_Aggregate; + /** fetch data from the table: "connector_config" using primary key columns */ + connector_config_by_pk?: Maybe; + /** fetch data from the table: "connector_deployment" */ + connector_connector_deployment: Array; + /** fetch aggregated fields from the table: "connector_deployment" */ + connector_connector_deployment_aggregate: Connector_Connector_Deployment_Aggregate; + /** fetch data from the table: "connector_deployment" using primary key columns */ + connector_connector_deployment_by_pk?: Maybe; + /** fetch data from the table: "connector_deployments" */ + connector_deployments: Array; + /** fetch aggregated fields from the table: "connector_deployments" */ + connector_deployments_aggregate: Connector_Deployments_Aggregate; + /** fetch data from the table: "connector_deployments" using primary key columns */ + connector_deployments_by_pk?: Maybe; /** fetch data from the table: "coupon" */ coupon: Array; /** fetch aggregated fields from the table: "coupon" */ @@ -50117,6 +53802,24 @@ export type Query_Root = { ddn_environment_aggregate: Ddn_Environment_Aggregate; /** fetch data from the table: "ddn.environment" using primary key columns */ ddn_environment_by_pk?: Maybe; + /** fetch data from the table: "ddn.project_entitlement_access" */ + ddn_project_entitlement_access: Array; + /** fetch aggregated fields from the table: "ddn.project_entitlement_access" */ + ddn_project_entitlement_access_aggregate: Ddn_Project_Entitlement_Access_Aggregate; + /** fetch data from the table: "ddn.project_entitlement_access" using primary key columns */ + ddn_project_entitlement_access_by_pk?: Maybe; + /** fetch data from the table: "ddn.project_entitlement_catalogue" */ + ddn_project_entitlement_catalogue: Array; + /** fetch aggregated fields from the table: "ddn.project_entitlement_catalogue" */ + ddn_project_entitlement_catalogue_aggregate: Ddn_Project_Entitlement_Catalogue_Aggregate; + /** fetch data from the table: "ddn.project_entitlement_catalogue" using primary key columns */ + ddn_project_entitlement_catalogue_by_pk?: Maybe; + /** fetch data from the table: "ddn.project_entitlement_types" */ + ddn_project_entitlement_types: Array; + /** fetch aggregated fields from the table: "ddn.project_entitlement_types" */ + ddn_project_entitlement_types_aggregate: Ddn_Project_Entitlement_Types_Aggregate; + /** fetch data from the table: "ddn.project_entitlement_types" using primary key columns */ + ddn_project_entitlement_types_by_pk?: Maybe; /** fetch data from the table: "ddn.projects" */ ddn_projects: Array; /** fetch aggregated fields from the table: "ddn.projects" */ @@ -50142,6 +53845,12 @@ export type Query_Root = { dedicated_cloud_bills_aggregate: Dedicated_Cloud_Bills_Aggregate; /** fetch data from the table: "dedicated_cloud_bills" using primary key columns */ dedicated_cloud_bills_by_pk?: Maybe; + /** fetch data from the table: "dedicated_cloud_bills_details" */ + dedicated_cloud_bills_details: Array; + /** fetch aggregated fields from the table: "dedicated_cloud_bills_details" */ + dedicated_cloud_bills_details_aggregate: Dedicated_Cloud_Bills_Details_Aggregate; + /** fetch data from the table: "dedicated_cloud_bills_details" using primary key columns */ + dedicated_cloud_bills_details_by_pk?: Maybe; /** fetch data from the table: "dedicated_cloud_commitments" */ dedicated_cloud_commitments: Array; /** fetch aggregated fields from the table: "dedicated_cloud_commitments" */ @@ -50220,6 +53929,9 @@ export type Query_Root = { feature_config_aggregate: Feature_Config_Aggregate; /** fetch data from the table: "feature_config" using primary key columns */ feature_config_by_pk?: Maybe; + fetchDedicatedCloudClusterBills?: Maybe< + Array + >; fetchPendingInvitations: Array; fetchPendingOwnershipInvitations: Array; fetchUserSupportTicketDetails?: Maybe>; @@ -50252,13 +53964,6 @@ export type Query_Root = { * aggregates on result of table type "project_total_db_usage_agg" */ get_aggregated_cost_for_project_on_shared_plan_aggregate: Project_Total_Db_Usage_Agg_Aggregate; - /** execute function "get_previous_schema_change_for_role" which returns "schema_registry_dumps" */ - get_previous_schema_change_for_role: Array; - /** - * execute function "get_previous_schema_change_for_role" and query aggregates on - * result of table type "schema_registry_dumps" - */ - get_previous_schema_change_for_role_aggregate: Schema_Registry_Dumps_Aggregate; getBuildVersion: BuildVersion; getComputeUnitAllocation?: Maybe; getComputeUnitUsage?: Maybe; @@ -50273,8 +53978,6 @@ export type Query_Root = { getNumberOfConnectedSources?: Maybe; getProjectMigrationStatus?: Maybe>>; getReportURL?: Maybe; - /** action gets the diff between two schema */ - getSchemaDiff?: Maybe; getTenantEnv?: Maybe; getTenantEnvConfigInfo?: Maybe; /** fetch data from the table: "github_email_type" */ @@ -50319,12 +54022,6 @@ export type Query_Root = { hasura_cluster_aggregate: Hasura_Cluster_Aggregate; /** fetch data from the table: "hasura_cluster" using primary key columns */ hasura_cluster_by_pk?: Maybe; - /** An array relationship */ - hasura_graphql_schema_tags: Array; - /** An aggregate relationship */ - hasura_graphql_schema_tags_aggregate: Hasura_Graphql_Schema_Tags_Aggregate; - /** fetch data from the table: "hasura_graphql_schema_tags" using primary key columns */ - hasura_graphql_schema_tags_by_pk?: Maybe; /** fetch data from the table: "hasura_worker" */ hasura_worker: Array; /** fetch aggregated fields from the table: "hasura_worker" */ @@ -50793,18 +54490,6 @@ export type Query_Root = { saml_idp_aggregate: Saml_Idp_Aggregate; /** fetch data from the table: "saml_idp" using primary key columns */ saml_idp_by_pk?: Maybe; - /** fetch data from the table: "schema_diff_data" */ - schema_diff_data: Array; - /** fetch aggregated fields from the table: "schema_diff_data" */ - schema_diff_data_aggregate: Schema_Diff_Data_Aggregate; - /** fetch data from the table: "schema_diff_data" using primary key columns */ - schema_diff_data_by_pk?: Maybe; - /** fetch data from the table: "schema_registry_dumps" */ - schema_registry_dumps: Array; - /** fetch aggregated fields from the table: "schema_registry_dumps" */ - schema_registry_dumps_aggregate: Schema_Registry_Dumps_Aggregate; - /** fetch data from the table: "schema_registry_dumps" using primary key columns */ - schema_registry_dumps_by_pk?: Maybe; /** execute function "search_project_login_status" which returns "search_project_login_status_results" */ search_project_login_status: Array; /** @@ -50820,6 +54505,12 @@ export type Query_Root = { search_tenant_group_has_least_members: Array; /** execute function "search_tenant_group_has_least_members" and query aggregates on result of table type "tenant_group" */ search_tenant_group_has_least_members_aggregate: Tenant_Group_Aggregate; + /** fetch data from the table: "slack_config" */ + slack_config: Array; + /** fetch aggregated fields from the table: "slack_config" */ + slack_config_aggregate: Slack_Config_Aggregate; + /** fetch data from the table: "slack_config" using primary key columns */ + slack_config_by_pk?: Maybe; status: Scalars['String']; /** fetch data from the table: "stripe_subscription" */ stripe_subscription: Array; @@ -50929,12 +54620,6 @@ export type Query_Root = { survey_v2_response_answer_option_by_pk?: Maybe; /** fetch data from the table: "survey_v2_response" using primary key columns */ survey_v2_response_by_pk?: Maybe; - /** fetch data from the table: "tag" */ - tag: Array; - /** fetch aggregated fields from the table: "tag" */ - tag_aggregate: Tag_Aggregate; - /** fetch data from the table: "tag" using primary key columns */ - tag_by_pk?: Maybe; /** fetch data from the table: "task_event" */ task_event: Array; /** fetch aggregated fields from the table: "task_event" */ @@ -51047,6 +54732,10 @@ export type Query_Root = { user_profile_aggregate: User_Profile_Aggregate; /** fetch data from the table: "user_profile" using primary key columns */ user_profile_by_pk?: Maybe; + /** fetch data from the table: "user_project_map" */ + user_project_map: Array; + /** fetch aggregated fields from the table: "user_project_map" */ + user_project_map_aggregate: User_Project_Map_Aggregate; /** fetch data from the table: "user_roles" */ user_roles: Array; /** fetch aggregated fields from the table: "user_roles" */ @@ -51115,6 +54804,108 @@ export type Query_Root = { zendesk_support_tickets_by_pk?: Maybe; }; +export type Query_RootAlert_ConfigArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Config_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Config_Alert_TypeArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Config_Alert_Type_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Config_Alert_Type_By_PkArgs = { + project_id: Scalars['uuid']; + type: Scalars['String']; +}; + +export type Query_RootAlert_Config_By_PkArgs = { + project_id: Scalars['uuid']; +}; + +export type Query_RootAlert_Config_ServiceArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Config_Service_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Config_Service_By_PkArgs = { + project_id: Scalars['uuid']; + type: Alert_Service_Type_Enum; +}; + +export type Query_RootAlert_Service_TypeArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Service_Type_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Service_Type_By_PkArgs = { + name: Scalars['String']; +}; + +export type Query_RootAlert_TypeArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Type_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootAlert_Type_By_PkArgs = { + id: Scalars['String']; +}; + export type Query_RootAzuremonitor_ConfigArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -51305,6 +55096,22 @@ export type Query_RootCloud_Metadata_By_PkArgs = { cloud: Cloud_Enum; }; +export type Query_RootCloud_Regions_By_PlanArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootCloud_Regions_By_Plan_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + export type Query_RootCompute_Project_Agg_Db_Usage_UserArgs = { args: Compute_Project_Agg_Db_Usage_User_Args; distinct_on?: Maybe>; @@ -51462,6 +55269,66 @@ export type Query_RootConfig_Status_By_PkArgs = { worker_id: Scalars['uuid']; }; +export type Query_RootConnector_ConfigArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootConnector_Config_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootConnector_Config_By_PkArgs = { + id: Scalars['uuid']; +}; + +export type Query_RootConnector_Connector_DeploymentArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootConnector_Connector_Deployment_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootConnector_Connector_Deployment_By_PkArgs = { + id: Scalars['connector_uuid']; +}; + +export type Query_RootConnector_DeploymentsArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootConnector_Deployments_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootConnector_Deployments_By_PkArgs = { + id: Scalars['uuid']; +}; + export type Query_RootCouponArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -51742,6 +55609,66 @@ export type Query_RootDdn_Environment_By_PkArgs = { id: Scalars['uuid']; }; +export type Query_RootDdn_Project_Entitlement_AccessArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootDdn_Project_Entitlement_Access_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootDdn_Project_Entitlement_Access_By_PkArgs = { + id: Scalars['uuid']; +}; + +export type Query_RootDdn_Project_Entitlement_CatalogueArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootDdn_Project_Entitlement_Catalogue_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootDdn_Project_Entitlement_Catalogue_By_PkArgs = { + id: Scalars['uuid']; +}; + +export type Query_RootDdn_Project_Entitlement_TypesArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootDdn_Project_Entitlement_Types_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootDdn_Project_Entitlement_Types_By_PkArgs = { + value: Scalars['String']; +}; + export type Query_RootDdn_ProjectsArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -51826,6 +55753,26 @@ export type Query_RootDedicated_Cloud_Bills_By_PkArgs = { id: Scalars['uuid']; }; +export type Query_RootDedicated_Cloud_Bills_DetailsArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootDedicated_Cloud_Bills_Details_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootDedicated_Cloud_Bills_Details_By_PkArgs = { + id: Scalars['uuid']; +}; + export type Query_RootDedicated_Cloud_CommitmentsArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -52089,6 +56036,12 @@ export type Query_RootFeature_Config_By_PkArgs = { feature: Feature_Enum; }; +export type Query_RootFetchDedicatedCloudClusterBillsArgs = { + month: Scalars['Int']; + user_id: Scalars['uuid']; + year: Scalars['Int']; +}; + export type Query_RootFetchUserSupportTicketDetailsArgs = { limit?: Maybe; offset?: Maybe; @@ -52191,24 +56144,6 @@ export type Query_RootGet_Aggregated_Cost_For_Project_On_Shared_Plan_AggregateAr where?: Maybe; }; -export type Query_RootGet_Previous_Schema_Change_For_RoleArgs = { - args: Get_Previous_Schema_Change_For_Role_Args; - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Query_RootGet_Previous_Schema_Change_For_Role_AggregateArgs = { - args: Get_Previous_Schema_Change_For_Role_Args; - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - export type Query_RootGetComputeUnitAllocationArgs = { cloud: CloudProvider; cluster_id: Scalars['String']; @@ -52243,10 +56178,6 @@ export type Query_RootGetReportUrlArgs = { key: Scalars['String']; }; -export type Query_RootGetSchemaDiffArgs = { - args: SchemaDiffInput; -}; - export type Query_RootGetTenantEnvArgs = { tenantId: Scalars['uuid']; }; @@ -52397,26 +56328,6 @@ export type Query_RootHasura_Cluster_By_PkArgs = { id: Scalars['uuid']; }; -export type Query_RootHasura_Graphql_Schema_TagsArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Query_RootHasura_Graphql_Schema_Tags_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Query_RootHasura_Graphql_Schema_Tags_By_PkArgs = { - id: Scalars['uuid']; -}; - export type Query_RootHasura_WorkerArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -54060,46 +57971,6 @@ export type Query_RootSaml_Idp_By_PkArgs = { id: Scalars['uuid']; }; -export type Query_RootSchema_Diff_DataArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Query_RootSchema_Diff_Data_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Query_RootSchema_Diff_Data_By_PkArgs = { - id: Scalars['uuid']; -}; - -export type Query_RootSchema_Registry_DumpsArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Query_RootSchema_Registry_Dumps_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Query_RootSchema_Registry_Dumps_By_PkArgs = { - id: Scalars['uuid']; -}; - export type Query_RootSearch_Project_Login_StatusArgs = { args: Search_Project_Login_Status_Args; distinct_on?: Maybe>; @@ -54152,6 +58023,26 @@ export type Query_RootSearch_Tenant_Group_Has_Least_Members_AggregateArgs = { where?: Maybe; }; +export type Query_RootSlack_ConfigArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootSlack_Config_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootSlack_Config_By_PkArgs = { + id: Scalars['uuid']; +}; + export type Query_RootStripe_SubscriptionArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -54523,26 +58414,6 @@ export type Query_RootSurvey_V2_Response_By_PkArgs = { id: Scalars['uuid']; }; -export type Query_RootTagArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Query_RootTag_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Query_RootTag_By_PkArgs = { - id: Scalars['uuid']; -}; - export type Query_RootTask_EventArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -54922,6 +58793,22 @@ export type Query_RootUser_Profile_By_PkArgs = { id: Scalars['uuid']; }; +export type Query_RootUser_Project_MapArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Query_RootUser_Project_Map_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + export type Query_RootUser_RolesArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -56471,6 +60358,8 @@ export type Saml_Idp_Bool_Exp = { /** unique or primary key constraints on table "saml_idp" */ export enum Saml_Idp_Constraint { + /** unique or primary key constraint on columns "domain" */ + SamlIdpDomainKey = 'saml_idp_domain_key', /** unique or primary key constraint on columns "id" */ SamlIdpPkey = 'saml_idp_pkey', } @@ -56612,875 +60501,6 @@ export type SaveSurveyAnswerV2Payload = { surveyName: Scalars['String']; }; -/** stores the schema diff for the user to read the diff on their schemas */ -export type Schema_Diff_Data = { - __typename?: 'schema_diff_data'; - created_at: Scalars['timestamptz']; - current_schema_hash: Scalars['String']; - current_schema_id: Scalars['uuid']; - former_schema_hash: Scalars['String']; - former_schema_id?: Maybe; - id: Scalars['uuid']; - schema_diff_data: Scalars['jsonb']; - /** An object relationship */ - schema_registry_dump_data: Schema_Registry_Dumps; - updated_at: Scalars['timestamptz']; -}; - -/** stores the schema diff for the user to read the diff on their schemas */ -export type Schema_Diff_DataSchema_Diff_DataArgs = { - path?: Maybe; -}; - -/** aggregated selection of "schema_diff_data" */ -export type Schema_Diff_Data_Aggregate = { - __typename?: 'schema_diff_data_aggregate'; - aggregate?: Maybe; - nodes: Array; -}; - -export type Schema_Diff_Data_Aggregate_Bool_Exp = { - count?: Maybe; -}; - -export type Schema_Diff_Data_Aggregate_Bool_Exp_Count = { - arguments?: Maybe>; - distinct?: Maybe; - filter?: Maybe; - predicate: Int_Comparison_Exp; -}; - -/** aggregate fields of "schema_diff_data" */ -export type Schema_Diff_Data_Aggregate_Fields = { - __typename?: 'schema_diff_data_aggregate_fields'; - count: Scalars['Int']; - max?: Maybe; - min?: Maybe; -}; - -/** aggregate fields of "schema_diff_data" */ -export type Schema_Diff_Data_Aggregate_FieldsCountArgs = { - columns?: Maybe>; - distinct?: Maybe; -}; - -/** order by aggregate values of table "schema_diff_data" */ -export type Schema_Diff_Data_Aggregate_Order_By = { - count?: Maybe; - max?: Maybe; - min?: Maybe; -}; - -/** append existing jsonb value of filtered columns with new jsonb value */ -export type Schema_Diff_Data_Append_Input = { - schema_diff_data?: Maybe; -}; - -/** input type for inserting array relation for remote table "schema_diff_data" */ -export type Schema_Diff_Data_Arr_Rel_Insert_Input = { - data: Array; - /** upsert condition */ - on_conflict?: Maybe; -}; - -/** Boolean expression to filter rows from the table "schema_diff_data". All fields are combined with a logical 'AND'. */ -export type Schema_Diff_Data_Bool_Exp = { - _and?: Maybe>; - _not?: Maybe; - _or?: Maybe>; - created_at?: Maybe; - current_schema_hash?: Maybe; - current_schema_id?: Maybe; - former_schema_hash?: Maybe; - former_schema_id?: Maybe; - id?: Maybe; - schema_diff_data?: Maybe; - schema_registry_dump_data?: Maybe; - updated_at?: Maybe; -}; - -/** unique or primary key constraints on table "schema_diff_data" */ -export enum Schema_Diff_Data_Constraint { - /** unique or primary key constraint on columns "id" */ - HasuraGraphqlSchemaPkey = 'hasura_graphql_schema_pkey', - /** unique or primary key constraint on columns "former_schema_id", "current_schema_id" */ - SchemaDiffDataCurrentSchemaIdFormerSchemaIdKey = 'schema_diff_data_current_schema_id_former_schema_id_key', -} - -/** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */ -export type Schema_Diff_Data_Delete_At_Path_Input = { - schema_diff_data?: Maybe>; -}; - -/** - * delete the array element with specified index (negative integers count from the - * end). throws an error if top level container is not an array - */ -export type Schema_Diff_Data_Delete_Elem_Input = { - schema_diff_data?: Maybe; -}; - -/** delete key/value pair or string element. key/value pairs are matched based on their key value */ -export type Schema_Diff_Data_Delete_Key_Input = { - schema_diff_data?: Maybe; -}; - -/** input type for inserting data into table "schema_diff_data" */ -export type Schema_Diff_Data_Insert_Input = { - created_at?: Maybe; - current_schema_hash?: Maybe; - current_schema_id?: Maybe; - former_schema_hash?: Maybe; - former_schema_id?: Maybe; - id?: Maybe; - schema_diff_data?: Maybe; - schema_registry_dump_data?: Maybe; - updated_at?: Maybe; -}; - -/** aggregate max on columns */ -export type Schema_Diff_Data_Max_Fields = { - __typename?: 'schema_diff_data_max_fields'; - created_at?: Maybe; - current_schema_hash?: Maybe; - current_schema_id?: Maybe; - former_schema_hash?: Maybe; - former_schema_id?: Maybe; - id?: Maybe; - updated_at?: Maybe; -}; - -/** order by max() on columns of table "schema_diff_data" */ -export type Schema_Diff_Data_Max_Order_By = { - created_at?: Maybe; - current_schema_hash?: Maybe; - current_schema_id?: Maybe; - former_schema_hash?: Maybe; - former_schema_id?: Maybe; - id?: Maybe; - updated_at?: Maybe; -}; - -/** aggregate min on columns */ -export type Schema_Diff_Data_Min_Fields = { - __typename?: 'schema_diff_data_min_fields'; - created_at?: Maybe; - current_schema_hash?: Maybe; - current_schema_id?: Maybe; - former_schema_hash?: Maybe; - former_schema_id?: Maybe; - id?: Maybe; - updated_at?: Maybe; -}; - -/** order by min() on columns of table "schema_diff_data" */ -export type Schema_Diff_Data_Min_Order_By = { - created_at?: Maybe; - current_schema_hash?: Maybe; - current_schema_id?: Maybe; - former_schema_hash?: Maybe; - former_schema_id?: Maybe; - id?: Maybe; - updated_at?: Maybe; -}; - -/** response of any mutation on the table "schema_diff_data" */ -export type Schema_Diff_Data_Mutation_Response = { - __typename?: 'schema_diff_data_mutation_response'; - /** number of rows affected by the mutation */ - affected_rows: Scalars['Int']; - /** data from the rows affected by the mutation */ - returning: Array; -}; - -/** input type for inserting object relation for remote table "schema_diff_data" */ -export type Schema_Diff_Data_Obj_Rel_Insert_Input = { - data: Schema_Diff_Data_Insert_Input; - /** upsert condition */ - on_conflict?: Maybe; -}; - -/** on_conflict condition type for table "schema_diff_data" */ -export type Schema_Diff_Data_On_Conflict = { - constraint: Schema_Diff_Data_Constraint; - update_columns?: Array; - where?: Maybe; -}; - -/** Ordering options when selecting data from "schema_diff_data". */ -export type Schema_Diff_Data_Order_By = { - created_at?: Maybe; - current_schema_hash?: Maybe; - current_schema_id?: Maybe; - former_schema_hash?: Maybe; - former_schema_id?: Maybe; - id?: Maybe; - schema_diff_data?: Maybe; - schema_registry_dump_data?: Maybe; - updated_at?: Maybe; -}; - -/** primary key columns input for table: schema_diff_data */ -export type Schema_Diff_Data_Pk_Columns_Input = { - id: Scalars['uuid']; -}; - -/** prepend existing jsonb value of filtered columns with new jsonb value */ -export type Schema_Diff_Data_Prepend_Input = { - schema_diff_data?: Maybe; -}; - -/** select columns of table "schema_diff_data" */ -export enum Schema_Diff_Data_Select_Column { - /** column name */ - CreatedAt = 'created_at', - /** column name */ - CurrentSchemaHash = 'current_schema_hash', - /** column name */ - CurrentSchemaId = 'current_schema_id', - /** column name */ - FormerSchemaHash = 'former_schema_hash', - /** column name */ - FormerSchemaId = 'former_schema_id', - /** column name */ - Id = 'id', - /** column name */ - SchemaDiffData = 'schema_diff_data', - /** column name */ - UpdatedAt = 'updated_at', -} - -/** input type for updating data in table "schema_diff_data" */ -export type Schema_Diff_Data_Set_Input = { - created_at?: Maybe; - current_schema_hash?: Maybe; - current_schema_id?: Maybe; - former_schema_hash?: Maybe; - former_schema_id?: Maybe; - id?: Maybe; - schema_diff_data?: Maybe; - updated_at?: Maybe; -}; - -/** Streaming cursor of the table "schema_diff_data" */ -export type Schema_Diff_Data_Stream_Cursor_Input = { - /** Stream column input with initial value */ - initial_value: Schema_Diff_Data_Stream_Cursor_Value_Input; - /** cursor ordering */ - ordering?: Maybe; -}; - -/** Initial value of the column from where the streaming should start */ -export type Schema_Diff_Data_Stream_Cursor_Value_Input = { - created_at?: Maybe; - current_schema_hash?: Maybe; - current_schema_id?: Maybe; - former_schema_hash?: Maybe; - former_schema_id?: Maybe; - id?: Maybe; - schema_diff_data?: Maybe; - updated_at?: Maybe; -}; - -/** update columns of table "schema_diff_data" */ -export enum Schema_Diff_Data_Update_Column { - /** column name */ - CreatedAt = 'created_at', - /** column name */ - CurrentSchemaHash = 'current_schema_hash', - /** column name */ - CurrentSchemaId = 'current_schema_id', - /** column name */ - FormerSchemaHash = 'former_schema_hash', - /** column name */ - FormerSchemaId = 'former_schema_id', - /** column name */ - Id = 'id', - /** column name */ - SchemaDiffData = 'schema_diff_data', - /** column name */ - UpdatedAt = 'updated_at', -} - -export type Schema_Diff_Data_Updates = { - /** append existing jsonb value of filtered columns with new jsonb value */ - _append?: Maybe; - /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */ - _delete_at_path?: Maybe; - /** - * delete the array element with specified index (negative integers count from - * the end). throws an error if top level container is not an array - */ - _delete_elem?: Maybe; - /** delete key/value pair or string element. key/value pairs are matched based on their key value */ - _delete_key?: Maybe; - /** prepend existing jsonb value of filtered columns with new jsonb value */ - _prepend?: Maybe; - /** sets the columns of the filtered rows to the given values */ - _set?: Maybe; - /** filter the rows which have to be updated */ - where: Schema_Diff_Data_Bool_Exp; -}; - -/** holds the schema changes for the database */ -export type Schema_Registry_Dumps = { - __typename?: 'schema_registry_dumps'; - change_recorded_at: Scalars['timestamptz']; - created_at: Scalars['timestamptz']; - /** An array relationship */ - diff_with_previous_schema: Array; - /** An aggregate relationship */ - diff_with_previous_schema_aggregate: Schema_Diff_Data_Aggregate; - entry_hash: Scalars['String']; - hasura_schema_role: Scalars['String']; - id: Scalars['uuid']; - is_metadata_inconsistent: Scalars['Boolean']; - metadata_resource_version: Scalars['bigint']; - project_id: Scalars['uuid']; - schema_hash: Scalars['String']; - schema_sdl: Scalars['String']; - /** An array relationship */ - sibling_schemas: Array; - /** An aggregate relationship */ - sibling_schemas_aggregate: Schema_Registry_Dumps_Aggregate; - tenant_id?: Maybe; - updated_at: Scalars['timestamptz']; - worker_id?: Maybe; -}; - -/** holds the schema changes for the database */ -export type Schema_Registry_DumpsDiff_With_Previous_SchemaArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -/** holds the schema changes for the database */ -export type Schema_Registry_DumpsDiff_With_Previous_Schema_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -/** holds the schema changes for the database */ -export type Schema_Registry_DumpsSibling_SchemasArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -/** holds the schema changes for the database */ -export type Schema_Registry_DumpsSibling_Schemas_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -/** aggregated selection of "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Aggregate = { - __typename?: 'schema_registry_dumps_aggregate'; - aggregate?: Maybe; - nodes: Array; -}; - -export type Schema_Registry_Dumps_Aggregate_Bool_Exp = { - bool_and?: Maybe; - bool_or?: Maybe; - count?: Maybe; -}; - -export type Schema_Registry_Dumps_Aggregate_Bool_Exp_Bool_And = { - arguments: Schema_Registry_Dumps_Select_Column_Schema_Registry_Dumps_Aggregate_Bool_Exp_Bool_And_Arguments_Columns; - distinct?: Maybe; - filter?: Maybe; - predicate: Boolean_Comparison_Exp; -}; - -export type Schema_Registry_Dumps_Aggregate_Bool_Exp_Bool_Or = { - arguments: Schema_Registry_Dumps_Select_Column_Schema_Registry_Dumps_Aggregate_Bool_Exp_Bool_Or_Arguments_Columns; - distinct?: Maybe; - filter?: Maybe; - predicate: Boolean_Comparison_Exp; -}; - -export type Schema_Registry_Dumps_Aggregate_Bool_Exp_Count = { - arguments?: Maybe>; - distinct?: Maybe; - filter?: Maybe; - predicate: Int_Comparison_Exp; -}; - -/** aggregate fields of "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Aggregate_Fields = { - __typename?: 'schema_registry_dumps_aggregate_fields'; - avg?: Maybe; - count: Scalars['Int']; - max?: Maybe; - min?: Maybe; - stddev?: Maybe; - stddev_pop?: Maybe; - stddev_samp?: Maybe; - sum?: Maybe; - var_pop?: Maybe; - var_samp?: Maybe; - variance?: Maybe; -}; - -/** aggregate fields of "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Aggregate_FieldsCountArgs = { - columns?: Maybe>; - distinct?: Maybe; -}; - -/** order by aggregate values of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Aggregate_Order_By = { - avg?: Maybe; - count?: Maybe; - max?: Maybe; - min?: Maybe; - stddev?: Maybe; - stddev_pop?: Maybe; - stddev_samp?: Maybe; - sum?: Maybe; - var_pop?: Maybe; - var_samp?: Maybe; - variance?: Maybe; -}; - -/** input type for inserting array relation for remote table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Arr_Rel_Insert_Input = { - data: Array; - /** upsert condition */ - on_conflict?: Maybe; -}; - -/** aggregate avg on columns */ -export type Schema_Registry_Dumps_Avg_Fields = { - __typename?: 'schema_registry_dumps_avg_fields'; - metadata_resource_version?: Maybe; -}; - -/** order by avg() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Avg_Order_By = { - metadata_resource_version?: Maybe; -}; - -/** Boolean expression to filter rows from the table "schema_registry_dumps". All fields are combined with a logical 'AND'. */ -export type Schema_Registry_Dumps_Bool_Exp = { - _and?: Maybe>; - _not?: Maybe; - _or?: Maybe>; - change_recorded_at?: Maybe; - created_at?: Maybe; - diff_with_previous_schema?: Maybe; - diff_with_previous_schema_aggregate?: Maybe; - entry_hash?: Maybe; - hasura_schema_role?: Maybe; - id?: Maybe; - is_metadata_inconsistent?: Maybe; - metadata_resource_version?: Maybe; - project_id?: Maybe; - schema_hash?: Maybe; - schema_sdl?: Maybe; - sibling_schemas?: Maybe; - sibling_schemas_aggregate?: Maybe; - tenant_id?: Maybe; - updated_at?: Maybe; - worker_id?: Maybe; -}; - -/** unique or primary key constraints on table "schema_registry_dumps" */ -export enum Schema_Registry_Dumps_Constraint { - /** - * unique or primary key constraint on columns "project_id", "schema_hash", - * "entry_hash", "metadata_resource_version", "hasura_schema_role" - */ - SchemaRegistryDumpsDedupKey = 'schema_registry_dumps_dedup_key', - /** unique or primary key constraint on columns "id" */ - SchemaRegistryDumpsPkey = 'schema_registry_dumps_pkey', - /** unique or primary key constraint on columns "schema_hash", "change_recorded_at" */ - SchemaRegistryDumpsSchemaHashChangeRecordedAtKey = 'schema_registry_dumps_schema_hash_change_recorded_at_key', -} - -/** input type for incrementing numeric columns in table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Inc_Input = { - metadata_resource_version?: Maybe; -}; - -/** input type for inserting data into table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Insert_Input = { - change_recorded_at?: Maybe; - created_at?: Maybe; - diff_with_previous_schema?: Maybe; - entry_hash?: Maybe; - hasura_schema_role?: Maybe; - id?: Maybe; - is_metadata_inconsistent?: Maybe; - metadata_resource_version?: Maybe; - project_id?: Maybe; - schema_hash?: Maybe; - schema_sdl?: Maybe; - sibling_schemas?: Maybe; - tenant_id?: Maybe; - updated_at?: Maybe; - worker_id?: Maybe; -}; - -/** aggregate max on columns */ -export type Schema_Registry_Dumps_Max_Fields = { - __typename?: 'schema_registry_dumps_max_fields'; - change_recorded_at?: Maybe; - created_at?: Maybe; - entry_hash?: Maybe; - hasura_schema_role?: Maybe; - id?: Maybe; - metadata_resource_version?: Maybe; - project_id?: Maybe; - schema_hash?: Maybe; - schema_sdl?: Maybe; - tenant_id?: Maybe; - updated_at?: Maybe; - worker_id?: Maybe; -}; - -/** order by max() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Max_Order_By = { - change_recorded_at?: Maybe; - created_at?: Maybe; - entry_hash?: Maybe; - hasura_schema_role?: Maybe; - id?: Maybe; - metadata_resource_version?: Maybe; - project_id?: Maybe; - schema_hash?: Maybe; - schema_sdl?: Maybe; - tenant_id?: Maybe; - updated_at?: Maybe; - worker_id?: Maybe; -}; - -/** aggregate min on columns */ -export type Schema_Registry_Dumps_Min_Fields = { - __typename?: 'schema_registry_dumps_min_fields'; - change_recorded_at?: Maybe; - created_at?: Maybe; - entry_hash?: Maybe; - hasura_schema_role?: Maybe; - id?: Maybe; - metadata_resource_version?: Maybe; - project_id?: Maybe; - schema_hash?: Maybe; - schema_sdl?: Maybe; - tenant_id?: Maybe; - updated_at?: Maybe; - worker_id?: Maybe; -}; - -/** order by min() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Min_Order_By = { - change_recorded_at?: Maybe; - created_at?: Maybe; - entry_hash?: Maybe; - hasura_schema_role?: Maybe; - id?: Maybe; - metadata_resource_version?: Maybe; - project_id?: Maybe; - schema_hash?: Maybe; - schema_sdl?: Maybe; - tenant_id?: Maybe; - updated_at?: Maybe; - worker_id?: Maybe; -}; - -/** response of any mutation on the table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Mutation_Response = { - __typename?: 'schema_registry_dumps_mutation_response'; - /** number of rows affected by the mutation */ - affected_rows: Scalars['Int']; - /** data from the rows affected by the mutation */ - returning: Array; -}; - -/** input type for inserting object relation for remote table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Obj_Rel_Insert_Input = { - data: Schema_Registry_Dumps_Insert_Input; - /** upsert condition */ - on_conflict?: Maybe; -}; - -/** on_conflict condition type for table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_On_Conflict = { - constraint: Schema_Registry_Dumps_Constraint; - update_columns?: Array; - where?: Maybe; -}; - -/** Ordering options when selecting data from "schema_registry_dumps". */ -export type Schema_Registry_Dumps_Order_By = { - change_recorded_at?: Maybe; - created_at?: Maybe; - diff_with_previous_schema_aggregate?: Maybe; - entry_hash?: Maybe; - hasura_schema_role?: Maybe; - id?: Maybe; - is_metadata_inconsistent?: Maybe; - metadata_resource_version?: Maybe; - project_id?: Maybe; - schema_hash?: Maybe; - schema_sdl?: Maybe; - sibling_schemas_aggregate?: Maybe; - tenant_id?: Maybe; - updated_at?: Maybe; - worker_id?: Maybe; -}; - -/** primary key columns input for table: schema_registry_dumps */ -export type Schema_Registry_Dumps_Pk_Columns_Input = { - id: Scalars['uuid']; -}; - -/** select columns of table "schema_registry_dumps" */ -export enum Schema_Registry_Dumps_Select_Column { - /** column name */ - ChangeRecordedAt = 'change_recorded_at', - /** column name */ - CreatedAt = 'created_at', - /** column name */ - EntryHash = 'entry_hash', - /** column name */ - HasuraSchemaRole = 'hasura_schema_role', - /** column name */ - Id = 'id', - /** column name */ - IsMetadataInconsistent = 'is_metadata_inconsistent', - /** column name */ - MetadataResourceVersion = 'metadata_resource_version', - /** column name */ - ProjectId = 'project_id', - /** column name */ - SchemaHash = 'schema_hash', - /** column name */ - SchemaSdl = 'schema_sdl', - /** column name */ - TenantId = 'tenant_id', - /** column name */ - UpdatedAt = 'updated_at', - /** column name */ - WorkerId = 'worker_id', -} - -/** select "schema_registry_dumps_aggregate_bool_exp_bool_and_arguments_columns" columns of table "schema_registry_dumps" */ -export enum Schema_Registry_Dumps_Select_Column_Schema_Registry_Dumps_Aggregate_Bool_Exp_Bool_And_Arguments_Columns { - /** column name */ - IsMetadataInconsistent = 'is_metadata_inconsistent', -} - -/** select "schema_registry_dumps_aggregate_bool_exp_bool_or_arguments_columns" columns of table "schema_registry_dumps" */ -export enum Schema_Registry_Dumps_Select_Column_Schema_Registry_Dumps_Aggregate_Bool_Exp_Bool_Or_Arguments_Columns { - /** column name */ - IsMetadataInconsistent = 'is_metadata_inconsistent', -} - -/** input type for updating data in table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Set_Input = { - change_recorded_at?: Maybe; - created_at?: Maybe; - entry_hash?: Maybe; - hasura_schema_role?: Maybe; - id?: Maybe; - is_metadata_inconsistent?: Maybe; - metadata_resource_version?: Maybe; - project_id?: Maybe; - schema_hash?: Maybe; - schema_sdl?: Maybe; - tenant_id?: Maybe; - updated_at?: Maybe; - worker_id?: Maybe; -}; - -/** aggregate stddev on columns */ -export type Schema_Registry_Dumps_Stddev_Fields = { - __typename?: 'schema_registry_dumps_stddev_fields'; - metadata_resource_version?: Maybe; -}; - -/** order by stddev() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Stddev_Order_By = { - metadata_resource_version?: Maybe; -}; - -/** aggregate stddev_pop on columns */ -export type Schema_Registry_Dumps_Stddev_Pop_Fields = { - __typename?: 'schema_registry_dumps_stddev_pop_fields'; - metadata_resource_version?: Maybe; -}; - -/** order by stddev_pop() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Stddev_Pop_Order_By = { - metadata_resource_version?: Maybe; -}; - -/** aggregate stddev_samp on columns */ -export type Schema_Registry_Dumps_Stddev_Samp_Fields = { - __typename?: 'schema_registry_dumps_stddev_samp_fields'; - metadata_resource_version?: Maybe; -}; - -/** order by stddev_samp() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Stddev_Samp_Order_By = { - metadata_resource_version?: Maybe; -}; - -/** Streaming cursor of the table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Stream_Cursor_Input = { - /** Stream column input with initial value */ - initial_value: Schema_Registry_Dumps_Stream_Cursor_Value_Input; - /** cursor ordering */ - ordering?: Maybe; -}; - -/** Initial value of the column from where the streaming should start */ -export type Schema_Registry_Dumps_Stream_Cursor_Value_Input = { - change_recorded_at?: Maybe; - created_at?: Maybe; - entry_hash?: Maybe; - hasura_schema_role?: Maybe; - id?: Maybe; - is_metadata_inconsistent?: Maybe; - metadata_resource_version?: Maybe; - project_id?: Maybe; - schema_hash?: Maybe; - schema_sdl?: Maybe; - tenant_id?: Maybe; - updated_at?: Maybe; - worker_id?: Maybe; -}; - -/** aggregate sum on columns */ -export type Schema_Registry_Dumps_Sum_Fields = { - __typename?: 'schema_registry_dumps_sum_fields'; - metadata_resource_version?: Maybe; -}; - -/** order by sum() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Sum_Order_By = { - metadata_resource_version?: Maybe; -}; - -/** update columns of table "schema_registry_dumps" */ -export enum Schema_Registry_Dumps_Update_Column { - /** column name */ - ChangeRecordedAt = 'change_recorded_at', - /** column name */ - CreatedAt = 'created_at', - /** column name */ - EntryHash = 'entry_hash', - /** column name */ - HasuraSchemaRole = 'hasura_schema_role', - /** column name */ - Id = 'id', - /** column name */ - IsMetadataInconsistent = 'is_metadata_inconsistent', - /** column name */ - MetadataResourceVersion = 'metadata_resource_version', - /** column name */ - ProjectId = 'project_id', - /** column name */ - SchemaHash = 'schema_hash', - /** column name */ - SchemaSdl = 'schema_sdl', - /** column name */ - TenantId = 'tenant_id', - /** column name */ - UpdatedAt = 'updated_at', - /** column name */ - WorkerId = 'worker_id', -} - -export type Schema_Registry_Dumps_Updates = { - /** increments the numeric columns with given value of the filtered values */ - _inc?: Maybe; - /** sets the columns of the filtered rows to the given values */ - _set?: Maybe; - /** filter the rows which have to be updated */ - where: Schema_Registry_Dumps_Bool_Exp; -}; - -/** aggregate var_pop on columns */ -export type Schema_Registry_Dumps_Var_Pop_Fields = { - __typename?: 'schema_registry_dumps_var_pop_fields'; - metadata_resource_version?: Maybe; -}; - -/** order by var_pop() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Var_Pop_Order_By = { - metadata_resource_version?: Maybe; -}; - -/** aggregate var_samp on columns */ -export type Schema_Registry_Dumps_Var_Samp_Fields = { - __typename?: 'schema_registry_dumps_var_samp_fields'; - metadata_resource_version?: Maybe; -}; - -/** order by var_samp() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Var_Samp_Order_By = { - metadata_resource_version?: Maybe; -}; - -/** aggregate variance on columns */ -export type Schema_Registry_Dumps_Variance_Fields = { - __typename?: 'schema_registry_dumps_variance_fields'; - metadata_resource_version?: Maybe; -}; - -/** order by variance() on columns of table "schema_registry_dumps" */ -export type Schema_Registry_Dumps_Variance_Order_By = { - metadata_resource_version?: Maybe; -}; - -export type SchemaDetails = { - hasura_schema_role: Scalars['String']; - schema_info: SchemaInfo; -}; - -export type SchemaDiffInput = { - currentSchemaID: Scalars['uuid']; - previousSchemaID: Scalars['uuid']; -}; - -export type SchemaDiffOutput = { - __typename?: 'SchemaDiffOutput'; - schemaDiff: Scalars['jsonb']; - schemaDiffID: Scalars['uuid']; - schemaID: Scalars['uuid']; -}; - -export type SchemaInfo = { - schema_hash: Scalars['String']; - schema_sdl: Scalars['String']; -}; - -export enum SchemaRegistryInputStatus { - Accepted = 'accepted', - Failed = 'failed', - Rejected = 'rejected', -} - -export type SchemaRegistryReadsOutput = { - __typename?: 'SchemaRegistryReadsOutput'; - message?: Maybe; - status: SchemaRegistryInputStatus; -}; - export type Search_Project_Login_Status_Args = { from_time?: Maybe; project_ids?: Maybe; @@ -57729,6 +60749,294 @@ export type SetVercelIntegrationOutput = { id: Scalars['String']; }; +/** stores the configuration for slack which user has configured */ +export type Slack_Config = { + __typename?: 'slack_config'; + /** An object relationship */ + alert_config?: Maybe; + channel_id?: Maybe; + channel_name?: Maybe; + created_at: Scalars['timestamptz']; + id: Scalars['uuid']; + project_id: Scalars['uuid']; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at: Scalars['timestamptz']; + webhook_url: Scalars['String']; +}; + +/** aggregated selection of "slack_config" */ +export type Slack_Config_Aggregate = { + __typename?: 'slack_config_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +export type Slack_Config_Aggregate_Bool_Exp = { + count?: Maybe; +}; + +export type Slack_Config_Aggregate_Bool_Exp_Count = { + arguments?: Maybe>; + distinct?: Maybe; + filter?: Maybe; + predicate: Int_Comparison_Exp; +}; + +/** aggregate fields of "slack_config" */ +export type Slack_Config_Aggregate_Fields = { + __typename?: 'slack_config_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "slack_config" */ +export type Slack_Config_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** order by aggregate values of table "slack_config" */ +export type Slack_Config_Aggregate_Order_By = { + count?: Maybe; + max?: Maybe; + min?: Maybe; +}; + +/** input type for inserting array relation for remote table "slack_config" */ +export type Slack_Config_Arr_Rel_Insert_Input = { + data: Array; + /** upsert condition */ + on_conflict?: Maybe; +}; + +/** Boolean expression to filter rows from the table "slack_config". All fields are combined with a logical 'AND'. */ +export type Slack_Config_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + alert_config?: Maybe; + channel_id?: Maybe; + channel_name?: Maybe; + created_at?: Maybe; + id?: Maybe; + project_id?: Maybe; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at?: Maybe; + webhook_url?: Maybe; +}; + +/** unique or primary key constraints on table "slack_config" */ +export enum Slack_Config_Constraint { + /** unique or primary key constraint on columns "id" */ + SlackConfigPkey = 'slack_config_pkey', + /** unique or primary key constraint on columns "project_id" */ + SlackConfigProjectIdKey = 'slack_config_project_id_key', +} + +/** input type for inserting data into table "slack_config" */ +export type Slack_Config_Insert_Input = { + alert_config?: Maybe; + channel_id?: Maybe; + channel_name?: Maybe; + created_at?: Maybe; + id?: Maybe; + project_id?: Maybe; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at?: Maybe; + webhook_url?: Maybe; +}; + +/** aggregate max on columns */ +export type Slack_Config_Max_Fields = { + __typename?: 'slack_config_max_fields'; + channel_id?: Maybe; + channel_name?: Maybe; + created_at?: Maybe; + id?: Maybe; + project_id?: Maybe; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at?: Maybe; + webhook_url?: Maybe; +}; + +/** order by max() on columns of table "slack_config" */ +export type Slack_Config_Max_Order_By = { + channel_id?: Maybe; + channel_name?: Maybe; + created_at?: Maybe; + id?: Maybe; + project_id?: Maybe; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at?: Maybe; + webhook_url?: Maybe; +}; + +/** aggregate min on columns */ +export type Slack_Config_Min_Fields = { + __typename?: 'slack_config_min_fields'; + channel_id?: Maybe; + channel_name?: Maybe; + created_at?: Maybe; + id?: Maybe; + project_id?: Maybe; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at?: Maybe; + webhook_url?: Maybe; +}; + +/** order by min() on columns of table "slack_config" */ +export type Slack_Config_Min_Order_By = { + channel_id?: Maybe; + channel_name?: Maybe; + created_at?: Maybe; + id?: Maybe; + project_id?: Maybe; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at?: Maybe; + webhook_url?: Maybe; +}; + +/** response of any mutation on the table "slack_config" */ +export type Slack_Config_Mutation_Response = { + __typename?: 'slack_config_mutation_response'; + /** number of rows affected by the mutation */ + affected_rows: Scalars['Int']; + /** data from the rows affected by the mutation */ + returning: Array; +}; + +/** input type for inserting object relation for remote table "slack_config" */ +export type Slack_Config_Obj_Rel_Insert_Input = { + data: Slack_Config_Insert_Input; + /** upsert condition */ + on_conflict?: Maybe; +}; + +/** on_conflict condition type for table "slack_config" */ +export type Slack_Config_On_Conflict = { + constraint: Slack_Config_Constraint; + update_columns?: Array; + where?: Maybe; +}; + +/** Ordering options when selecting data from "slack_config". */ +export type Slack_Config_Order_By = { + alert_config?: Maybe; + channel_id?: Maybe; + channel_name?: Maybe; + created_at?: Maybe; + id?: Maybe; + project_id?: Maybe; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at?: Maybe; + webhook_url?: Maybe; +}; + +/** primary key columns input for table: slack_config */ +export type Slack_Config_Pk_Columns_Input = { + id: Scalars['uuid']; +}; + +/** select columns of table "slack_config" */ +export enum Slack_Config_Select_Column { + /** column name */ + ChannelId = 'channel_id', + /** column name */ + ChannelName = 'channel_name', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Id = 'id', + /** column name */ + ProjectId = 'project_id', + /** column name */ + SlackTeamId = 'slack_team_id', + /** column name */ + TeamName = 'team_name', + /** column name */ + UpdatedAt = 'updated_at', + /** column name */ + WebhookUrl = 'webhook_url', +} + +/** input type for updating data in table "slack_config" */ +export type Slack_Config_Set_Input = { + channel_id?: Maybe; + channel_name?: Maybe; + created_at?: Maybe; + id?: Maybe; + project_id?: Maybe; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at?: Maybe; + webhook_url?: Maybe; +}; + +/** Streaming cursor of the table "slack_config" */ +export type Slack_Config_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: Slack_Config_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type Slack_Config_Stream_Cursor_Value_Input = { + channel_id?: Maybe; + channel_name?: Maybe; + created_at?: Maybe; + id?: Maybe; + project_id?: Maybe; + slack_team_id?: Maybe; + team_name?: Maybe; + updated_at?: Maybe; + webhook_url?: Maybe; +}; + +/** update columns of table "slack_config" */ +export enum Slack_Config_Update_Column { + /** column name */ + ChannelId = 'channel_id', + /** column name */ + ChannelName = 'channel_name', + /** column name */ + CreatedAt = 'created_at', + /** column name */ + Id = 'id', + /** column name */ + ProjectId = 'project_id', + /** column name */ + SlackTeamId = 'slack_team_id', + /** column name */ + TeamName = 'team_name', + /** column name */ + UpdatedAt = 'updated_at', + /** column name */ + WebhookUrl = 'webhook_url', +} + +export type Slack_Config_Updates = { + /** sets the columns of the filtered rows to the given values */ + _set?: Maybe; + /** filter the rows which have to be updated */ + where: Slack_Config_Bool_Exp; +}; + +export type SlackExchangeTokenResponse = { + __typename?: 'SlackExchangeTokenResponse'; + channel_name: Scalars['String']; + team_name: Scalars['String']; +}; + /** Boolean expression to compare columns of type "smallint". All fields are combined with logical 'AND'. */ export type Smallint_Comparison_Exp = { _eq?: Maybe; @@ -58257,6 +61565,46 @@ export type StripeCardResponse = { export type Subscription_Root = { __typename?: 'subscription_root'; + /** fetch data from the table: "alert_config" */ + alert_config: Array; + /** fetch aggregated fields from the table: "alert_config" */ + alert_config_aggregate: Alert_Config_Aggregate; + /** fetch data from the table: "alert_config_alert_type" */ + alert_config_alert_type: Array; + /** fetch aggregated fields from the table: "alert_config_alert_type" */ + alert_config_alert_type_aggregate: Alert_Config_Alert_Type_Aggregate; + /** fetch data from the table: "alert_config_alert_type" using primary key columns */ + alert_config_alert_type_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "alert_config_alert_type" */ + alert_config_alert_type_stream: Array; + /** fetch data from the table: "alert_config" using primary key columns */ + alert_config_by_pk?: Maybe; + /** fetch data from the table: "alert_config_service" */ + alert_config_service: Array; + /** fetch aggregated fields from the table: "alert_config_service" */ + alert_config_service_aggregate: Alert_Config_Service_Aggregate; + /** fetch data from the table: "alert_config_service" using primary key columns */ + alert_config_service_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "alert_config_service" */ + alert_config_service_stream: Array; + /** fetch data from the table in a streaming manner: "alert_config" */ + alert_config_stream: Array; + /** fetch data from the table: "alert_service_type" */ + alert_service_type: Array; + /** fetch aggregated fields from the table: "alert_service_type" */ + alert_service_type_aggregate: Alert_Service_Type_Aggregate; + /** fetch data from the table: "alert_service_type" using primary key columns */ + alert_service_type_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "alert_service_type" */ + alert_service_type_stream: Array; + /** fetch data from the table: "alert_type" */ + alert_type: Array; + /** fetch aggregated fields from the table: "alert_type" */ + alert_type_aggregate: Alert_Type_Aggregate; + /** fetch data from the table: "alert_type" using primary key columns */ + alert_type_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "alert_type" */ + alert_type_stream: Array; /** fetch data from the table: "azuremonitor_config" */ azuremonitor_config: Array; /** fetch aggregated fields from the table: "azuremonitor_config" */ @@ -58330,6 +61678,12 @@ export type Subscription_Root = { cloud_metadata_by_pk?: Maybe; /** fetch data from the table in a streaming manner: "cloud_metadata" */ cloud_metadata_stream: Array; + /** fetch data from the table: "cloud_regions_by_plan" */ + cloud_regions_by_plan: Array; + /** fetch aggregated fields from the table: "cloud_regions_by_plan" */ + cloud_regions_by_plan_aggregate: Cloud_Regions_By_Plan_Aggregate; + /** fetch data from the table in a streaming manner: "cloud_regions_by_plan" */ + cloud_regions_by_plan_stream: Array; /** fetch data from the table in a streaming manner: "cloud" */ cloud_stream: Array; /** execute function "compute_project_agg_db_usage_user" which returns "project_db_usage_agg_user" */ @@ -58388,6 +61742,30 @@ export type Subscription_Root = { config_status_stream: Array; /** fetch data from the table in a streaming manner: "config" */ config_stream: Array; + /** fetch data from the table: "connector_config" */ + connector_config: Array; + /** fetch aggregated fields from the table: "connector_config" */ + connector_config_aggregate: Connector_Config_Aggregate; + /** fetch data from the table: "connector_config" using primary key columns */ + connector_config_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "connector_config" */ + connector_config_stream: Array; + /** fetch data from the table: "connector_deployment" */ + connector_deployment: Array; + /** fetch aggregated fields from the table: "connector_deployment" */ + connector_deployment_aggregate: Connector_Connector_Deployment_Aggregate; + /** fetch data from the table: "connector_deployment" using primary key columns */ + connector_deployment_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "connector_deployment" */ + connector_deployment_stream: Array; + /** fetch data from the table: "connector_deployments" */ + connector_deployments: Array; + /** fetch aggregated fields from the table: "connector_deployments" */ + connector_deployments_aggregate: Connector_Deployments_Aggregate; + /** fetch data from the table: "connector_deployments" using primary key columns */ + connector_deployments_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "connector_deployments" */ + connector_deployments_stream: Array; /** fetch data from the table: "coupon" */ coupon: Array; /** fetch aggregated fields from the table: "coupon" */ @@ -58500,6 +61878,30 @@ export type Subscription_Root = { ddn_environment_by_pk?: Maybe; /** fetch data from the table in a streaming manner: "ddn.environment" */ ddn_environment_stream: Array; + /** fetch data from the table: "ddn.project_entitlement_access" */ + ddn_project_entitlement_access: Array; + /** fetch aggregated fields from the table: "ddn.project_entitlement_access" */ + ddn_project_entitlement_access_aggregate: Ddn_Project_Entitlement_Access_Aggregate; + /** fetch data from the table: "ddn.project_entitlement_access" using primary key columns */ + ddn_project_entitlement_access_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "ddn.project_entitlement_access" */ + ddn_project_entitlement_access_stream: Array; + /** fetch data from the table: "ddn.project_entitlement_catalogue" */ + ddn_project_entitlement_catalogue: Array; + /** fetch aggregated fields from the table: "ddn.project_entitlement_catalogue" */ + ddn_project_entitlement_catalogue_aggregate: Ddn_Project_Entitlement_Catalogue_Aggregate; + /** fetch data from the table: "ddn.project_entitlement_catalogue" using primary key columns */ + ddn_project_entitlement_catalogue_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "ddn.project_entitlement_catalogue" */ + ddn_project_entitlement_catalogue_stream: Array; + /** fetch data from the table: "ddn.project_entitlement_types" */ + ddn_project_entitlement_types: Array; + /** fetch aggregated fields from the table: "ddn.project_entitlement_types" */ + ddn_project_entitlement_types_aggregate: Ddn_Project_Entitlement_Types_Aggregate; + /** fetch data from the table: "ddn.project_entitlement_types" using primary key columns */ + ddn_project_entitlement_types_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "ddn.project_entitlement_types" */ + ddn_project_entitlement_types_stream: Array; /** fetch data from the table: "ddn.projects" */ ddn_projects: Array; /** fetch aggregated fields from the table: "ddn.projects" */ @@ -58530,6 +61932,14 @@ export type Subscription_Root = { dedicated_cloud_bills_aggregate: Dedicated_Cloud_Bills_Aggregate; /** fetch data from the table: "dedicated_cloud_bills" using primary key columns */ dedicated_cloud_bills_by_pk?: Maybe; + /** fetch data from the table: "dedicated_cloud_bills_details" */ + dedicated_cloud_bills_details: Array; + /** fetch aggregated fields from the table: "dedicated_cloud_bills_details" */ + dedicated_cloud_bills_details_aggregate: Dedicated_Cloud_Bills_Details_Aggregate; + /** fetch data from the table: "dedicated_cloud_bills_details" using primary key columns */ + dedicated_cloud_bills_details_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "dedicated_cloud_bills_details" */ + dedicated_cloud_bills_details_stream: Array; /** fetch data from the table in a streaming manner: "dedicated_cloud_bills" */ dedicated_cloud_bills_stream: Array; /** fetch data from the table: "dedicated_cloud_commitments" */ @@ -58673,13 +62083,6 @@ export type Subscription_Root = { * aggregates on result of table type "project_total_db_usage_agg" */ get_aggregated_cost_for_project_on_shared_plan_aggregate: Project_Total_Db_Usage_Agg_Aggregate; - /** execute function "get_previous_schema_change_for_role" which returns "schema_registry_dumps" */ - get_previous_schema_change_for_role: Array; - /** - * execute function "get_previous_schema_change_for_role" and query aggregates on - * result of table type "schema_registry_dumps" - */ - get_previous_schema_change_for_role_aggregate: Schema_Registry_Dumps_Aggregate; /** fetch data from the table: "github_email_type" */ github_email_type: Array; /** fetch aggregated fields from the table: "github_email_type" */ @@ -58736,14 +62139,6 @@ export type Subscription_Root = { hasura_cluster_by_pk?: Maybe; /** fetch data from the table in a streaming manner: "hasura_cluster" */ hasura_cluster_stream: Array; - /** An array relationship */ - hasura_graphql_schema_tags: Array; - /** An aggregate relationship */ - hasura_graphql_schema_tags_aggregate: Hasura_Graphql_Schema_Tags_Aggregate; - /** fetch data from the table: "hasura_graphql_schema_tags" using primary key columns */ - hasura_graphql_schema_tags_by_pk?: Maybe; - /** fetch data from the table in a streaming manner: "hasura_graphql_schema_tags" */ - hasura_graphql_schema_tags_stream: Array; /** fetch data from the table: "hasura_worker" */ hasura_worker: Array; /** fetch aggregated fields from the table: "hasura_worker" */ @@ -59371,22 +62766,6 @@ export type Subscription_Root = { saml_idp_by_pk?: Maybe; /** fetch data from the table in a streaming manner: "saml_idp" */ saml_idp_stream: Array; - /** fetch data from the table: "schema_diff_data" */ - schema_diff_data: Array; - /** fetch aggregated fields from the table: "schema_diff_data" */ - schema_diff_data_aggregate: Schema_Diff_Data_Aggregate; - /** fetch data from the table: "schema_diff_data" using primary key columns */ - schema_diff_data_by_pk?: Maybe; - /** fetch data from the table in a streaming manner: "schema_diff_data" */ - schema_diff_data_stream: Array; - /** fetch data from the table: "schema_registry_dumps" */ - schema_registry_dumps: Array; - /** fetch aggregated fields from the table: "schema_registry_dumps" */ - schema_registry_dumps_aggregate: Schema_Registry_Dumps_Aggregate; - /** fetch data from the table: "schema_registry_dumps" using primary key columns */ - schema_registry_dumps_by_pk?: Maybe; - /** fetch data from the table in a streaming manner: "schema_registry_dumps" */ - schema_registry_dumps_stream: Array; /** execute function "search_project_login_status" which returns "search_project_login_status_results" */ search_project_login_status: Array; /** @@ -59404,6 +62783,14 @@ export type Subscription_Root = { search_tenant_group_has_least_members: Array; /** execute function "search_tenant_group_has_least_members" and query aggregates on result of table type "tenant_group" */ search_tenant_group_has_least_members_aggregate: Tenant_Group_Aggregate; + /** fetch data from the table: "slack_config" */ + slack_config: Array; + /** fetch aggregated fields from the table: "slack_config" */ + slack_config_aggregate: Slack_Config_Aggregate; + /** fetch data from the table: "slack_config" using primary key columns */ + slack_config_by_pk?: Maybe; + /** fetch data from the table in a streaming manner: "slack_config" */ + slack_config_stream: Array; /** fetch data from the table: "stripe_subscription" */ stripe_subscription: Array; /** fetch aggregated fields from the table: "stripe_subscription" */ @@ -59548,14 +62935,6 @@ export type Subscription_Root = { survey_v2_response_stream: Array; /** fetch data from the table in a streaming manner: "survey_v2" */ survey_v2_stream: Array; - /** fetch data from the table: "tag" */ - tag: Array; - /** fetch aggregated fields from the table: "tag" */ - tag_aggregate: Tag_Aggregate; - /** fetch data from the table: "tag" using primary key columns */ - tag_by_pk?: Maybe; - /** fetch data from the table in a streaming manner: "tag" */ - tag_stream: Array; /** fetch data from the table: "task_event" */ task_event: Array; /** fetch aggregated fields from the table: "task_event" */ @@ -59706,6 +63085,12 @@ export type Subscription_Root = { user_profile_by_pk?: Maybe; /** fetch data from the table in a streaming manner: "user_profile" */ user_profile_stream: Array; + /** fetch data from the table: "user_project_map" */ + user_project_map: Array; + /** fetch aggregated fields from the table: "user_project_map" */ + user_project_map_aggregate: User_Project_Map_Aggregate; + /** fetch data from the table in a streaming manner: "user_project_map" */ + user_project_map_stream: Array; /** fetch data from the table: "user_roles" */ user_roles: Array; /** fetch aggregated fields from the table: "user_roles" */ @@ -59794,6 +63179,138 @@ export type Subscription_Root = { zendesk_support_tickets_stream: Array; }; +export type Subscription_RootAlert_ConfigArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Config_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Config_Alert_TypeArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Config_Alert_Type_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Config_Alert_Type_By_PkArgs = { + project_id: Scalars['uuid']; + type: Scalars['String']; +}; + +export type Subscription_RootAlert_Config_Alert_Type_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Config_By_PkArgs = { + project_id: Scalars['uuid']; +}; + +export type Subscription_RootAlert_Config_ServiceArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Config_Service_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Config_Service_By_PkArgs = { + project_id: Scalars['uuid']; + type: Alert_Service_Type_Enum; +}; + +export type Subscription_RootAlert_Config_Service_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Config_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Service_TypeArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Service_Type_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Service_Type_By_PkArgs = { + name: Scalars['String']; +}; + +export type Subscription_RootAlert_Service_Type_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + +export type Subscription_RootAlert_TypeArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Type_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootAlert_Type_By_PkArgs = { + id: Scalars['String']; +}; + +export type Subscription_RootAlert_Type_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + export type Subscription_RootAzuremonitor_ConfigArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -60032,6 +63549,28 @@ export type Subscription_RootCloud_Metadata_StreamArgs = { where?: Maybe; }; +export type Subscription_RootCloud_Regions_By_PlanArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootCloud_Regions_By_Plan_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootCloud_Regions_By_Plan_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + export type Subscription_RootCloud_StreamArgs = { batch_size: Scalars['Int']; cursor: Array>; @@ -60214,6 +63753,84 @@ export type Subscription_RootConfig_StreamArgs = { where?: Maybe; }; +export type Subscription_RootConnector_ConfigArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootConnector_Config_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootConnector_Config_By_PkArgs = { + id: Scalars['uuid']; +}; + +export type Subscription_RootConnector_Config_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + +export type Subscription_RootConnector_DeploymentArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootConnector_Deployment_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootConnector_Deployment_By_PkArgs = { + id: Scalars['connector_uuid']; +}; + +export type Subscription_RootConnector_Deployment_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + +export type Subscription_RootConnector_DeploymentsArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootConnector_Deployments_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootConnector_Deployments_By_PkArgs = { + id: Scalars['uuid']; +}; + +export type Subscription_RootConnector_Deployments_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + export type Subscription_RootCouponArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -60578,6 +64195,84 @@ export type Subscription_RootDdn_Environment_StreamArgs = { where?: Maybe; }; +export type Subscription_RootDdn_Project_Entitlement_AccessArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootDdn_Project_Entitlement_Access_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootDdn_Project_Entitlement_Access_By_PkArgs = { + id: Scalars['uuid']; +}; + +export type Subscription_RootDdn_Project_Entitlement_Access_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + +export type Subscription_RootDdn_Project_Entitlement_CatalogueArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootDdn_Project_Entitlement_Catalogue_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootDdn_Project_Entitlement_Catalogue_By_PkArgs = { + id: Scalars['uuid']; +}; + +export type Subscription_RootDdn_Project_Entitlement_Catalogue_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + +export type Subscription_RootDdn_Project_Entitlement_TypesArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootDdn_Project_Entitlement_Types_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootDdn_Project_Entitlement_Types_By_PkArgs = { + value: Scalars['String']; +}; + +export type Subscription_RootDdn_Project_Entitlement_Types_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + export type Subscription_RootDdn_ProjectsArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -60676,6 +64371,32 @@ export type Subscription_RootDedicated_Cloud_Bills_By_PkArgs = { id: Scalars['uuid']; }; +export type Subscription_RootDedicated_Cloud_Bills_DetailsArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootDedicated_Cloud_Bills_Details_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootDedicated_Cloud_Bills_Details_By_PkArgs = { + id: Scalars['uuid']; +}; + +export type Subscription_RootDedicated_Cloud_Bills_Details_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + export type Subscription_RootDedicated_Cloud_Bills_StreamArgs = { batch_size: Scalars['Int']; cursor: Array>; @@ -61145,25 +64866,6 @@ export type Subscription_RootGet_Aggregated_Cost_For_Project_On_Shared_Plan_Aggr where?: Maybe; }; -export type Subscription_RootGet_Previous_Schema_Change_For_RoleArgs = { - args: Get_Previous_Schema_Change_For_Role_Args; - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Subscription_RootGet_Previous_Schema_Change_For_Role_AggregateArgs = - { - args: Get_Previous_Schema_Change_For_Role_Args; - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; - }; - export type Subscription_RootGithub_Email_TypeArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -61348,32 +65050,6 @@ export type Subscription_RootHasura_Cluster_StreamArgs = { where?: Maybe; }; -export type Subscription_RootHasura_Graphql_Schema_TagsArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Subscription_RootHasura_Graphql_Schema_Tags_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Subscription_RootHasura_Graphql_Schema_Tags_By_PkArgs = { - id: Scalars['uuid']; -}; - -export type Subscription_RootHasura_Graphql_Schema_Tags_StreamArgs = { - batch_size: Scalars['Int']; - cursor: Array>; - where?: Maybe; -}; - export type Subscription_RootHasura_WorkerArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -63531,58 +67207,6 @@ export type Subscription_RootSaml_Idp_StreamArgs = { where?: Maybe; }; -export type Subscription_RootSchema_Diff_DataArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Subscription_RootSchema_Diff_Data_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Subscription_RootSchema_Diff_Data_By_PkArgs = { - id: Scalars['uuid']; -}; - -export type Subscription_RootSchema_Diff_Data_StreamArgs = { - batch_size: Scalars['Int']; - cursor: Array>; - where?: Maybe; -}; - -export type Subscription_RootSchema_Registry_DumpsArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Subscription_RootSchema_Registry_Dumps_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Subscription_RootSchema_Registry_Dumps_By_PkArgs = { - id: Scalars['uuid']; -}; - -export type Subscription_RootSchema_Registry_Dumps_StreamArgs = { - batch_size: Scalars['Int']; - cursor: Array>; - where?: Maybe; -}; - export type Subscription_RootSearch_Project_Login_StatusArgs = { args: Search_Project_Login_Status_Args; distinct_on?: Maybe>; @@ -63645,6 +67269,32 @@ export type Subscription_RootSearch_Tenant_Group_Has_Least_Members_AggregateArgs where?: Maybe; }; +export type Subscription_RootSlack_ConfigArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootSlack_Config_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootSlack_Config_By_PkArgs = { + id: Scalars['uuid']; +}; + +export type Subscription_RootSlack_Config_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + export type Subscription_RootStripe_SubscriptionArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -64128,32 +67778,6 @@ export type Subscription_RootSurvey_V2_StreamArgs = { where?: Maybe; }; -export type Subscription_RootTagArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Subscription_RootTag_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -export type Subscription_RootTag_By_PkArgs = { - id: Scalars['uuid']; -}; - -export type Subscription_RootTag_StreamArgs = { - batch_size: Scalars['Int']; - cursor: Array>; - where?: Maybe; -}; - export type Subscription_RootTask_EventArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -64647,6 +68271,28 @@ export type Subscription_RootUser_Profile_StreamArgs = { where?: Maybe; }; +export type Subscription_RootUser_Project_MapArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootUser_Project_Map_AggregateArgs = { + distinct_on?: Maybe>; + limit?: Maybe; + offset?: Maybe; + order_by?: Maybe>; + where?: Maybe; +}; + +export type Subscription_RootUser_Project_Map_StreamArgs = { + batch_size: Scalars['Int']; + cursor: Array>; + where?: Maybe; +}; + export type Subscription_RootUser_RolesArgs = { distinct_on?: Maybe>; limit?: Maybe; @@ -69100,208 +72746,6 @@ export type SurveyResponseV2 = { questionId: Scalars['uuid']; }; -/** Tags for schema changes */ -export type Tag = { - __typename?: 'tag'; - color?: Maybe; - created_at: Scalars['timestamptz']; - /** An array relationship */ - hasura_graphql_schema_tags: Array; - /** An aggregate relationship */ - hasura_graphql_schema_tags_aggregate: Hasura_Graphql_Schema_Tags_Aggregate; - id: Scalars['uuid']; - name: Scalars['String']; - user_id: Scalars['uuid']; -}; - -/** Tags for schema changes */ -export type TagHasura_Graphql_Schema_TagsArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -/** Tags for schema changes */ -export type TagHasura_Graphql_Schema_Tags_AggregateArgs = { - distinct_on?: Maybe>; - limit?: Maybe; - offset?: Maybe; - order_by?: Maybe>; - where?: Maybe; -}; - -/** aggregated selection of "tag" */ -export type Tag_Aggregate = { - __typename?: 'tag_aggregate'; - aggregate?: Maybe; - nodes: Array; -}; - -/** aggregate fields of "tag" */ -export type Tag_Aggregate_Fields = { - __typename?: 'tag_aggregate_fields'; - count: Scalars['Int']; - max?: Maybe; - min?: Maybe; -}; - -/** aggregate fields of "tag" */ -export type Tag_Aggregate_FieldsCountArgs = { - columns?: Maybe>; - distinct?: Maybe; -}; - -/** Boolean expression to filter rows from the table "tag". All fields are combined with a logical 'AND'. */ -export type Tag_Bool_Exp = { - _and?: Maybe>; - _not?: Maybe; - _or?: Maybe>; - color?: Maybe; - created_at?: Maybe; - hasura_graphql_schema_tags?: Maybe; - hasura_graphql_schema_tags_aggregate?: Maybe; - id?: Maybe; - name?: Maybe; - user_id?: Maybe; -}; - -/** unique or primary key constraints on table "tag" */ -export enum Tag_Constraint { - /** unique or primary key constraint on columns "id" */ - TagPkey = 'tag_pkey', -} - -/** input type for inserting data into table "tag" */ -export type Tag_Insert_Input = { - color?: Maybe; - created_at?: Maybe; - hasura_graphql_schema_tags?: Maybe; - id?: Maybe; - name?: Maybe; - user_id?: Maybe; -}; - -/** aggregate max on columns */ -export type Tag_Max_Fields = { - __typename?: 'tag_max_fields'; - color?: Maybe; - created_at?: Maybe; - id?: Maybe; - name?: Maybe; - user_id?: Maybe; -}; - -/** aggregate min on columns */ -export type Tag_Min_Fields = { - __typename?: 'tag_min_fields'; - color?: Maybe; - created_at?: Maybe; - id?: Maybe; - name?: Maybe; - user_id?: Maybe; -}; - -/** response of any mutation on the table "tag" */ -export type Tag_Mutation_Response = { - __typename?: 'tag_mutation_response'; - /** number of rows affected by the mutation */ - affected_rows: Scalars['Int']; - /** data from the rows affected by the mutation */ - returning: Array; -}; - -/** input type for inserting object relation for remote table "tag" */ -export type Tag_Obj_Rel_Insert_Input = { - data: Tag_Insert_Input; - /** upsert condition */ - on_conflict?: Maybe; -}; - -/** on_conflict condition type for table "tag" */ -export type Tag_On_Conflict = { - constraint: Tag_Constraint; - update_columns?: Array; - where?: Maybe; -}; - -/** Ordering options when selecting data from "tag". */ -export type Tag_Order_By = { - color?: Maybe; - created_at?: Maybe; - hasura_graphql_schema_tags_aggregate?: Maybe; - id?: Maybe; - name?: Maybe; - user_id?: Maybe; -}; - -/** primary key columns input for table: tag */ -export type Tag_Pk_Columns_Input = { - id: Scalars['uuid']; -}; - -/** select columns of table "tag" */ -export enum Tag_Select_Column { - /** column name */ - Color = 'color', - /** column name */ - CreatedAt = 'created_at', - /** column name */ - Id = 'id', - /** column name */ - Name = 'name', - /** column name */ - UserId = 'user_id', -} - -/** input type for updating data in table "tag" */ -export type Tag_Set_Input = { - color?: Maybe; - created_at?: Maybe; - id?: Maybe; - name?: Maybe; - user_id?: Maybe; -}; - -/** Streaming cursor of the table "tag" */ -export type Tag_Stream_Cursor_Input = { - /** Stream column input with initial value */ - initial_value: Tag_Stream_Cursor_Value_Input; - /** cursor ordering */ - ordering?: Maybe; -}; - -/** Initial value of the column from where the streaming should start */ -export type Tag_Stream_Cursor_Value_Input = { - color?: Maybe; - created_at?: Maybe; - id?: Maybe; - name?: Maybe; - user_id?: Maybe; -}; - -/** update columns of table "tag" */ -export enum Tag_Update_Column { - /** column name */ - Color = 'color', - /** column name */ - CreatedAt = 'created_at', - /** column name */ - Id = 'id', - /** column name */ - Name = 'name', - /** column name */ - UserId = 'user_id', -} - -export type Tag_Updates = { - /** sets the columns of the filtered rows to the given values */ - _set?: Maybe; - /** filter the rows which have to be updated */ - where: Tag_Bool_Exp; -}; - /** columns and relationships of "task_event" */ export type Task_Event = { __typename?: 'task_event'; @@ -74235,6 +77679,12 @@ export enum User_Entitlement_Types_Enum { DedicatedCloudNonPgDb = 'dedicated_cloud_non_pg_db', /** Access and unit cost correpsonding Postgres database on the Dedicated Cloud Plan. */ DedicatedCloudPgDb = 'dedicated_cloud_pg_db', + /** Configure access to user assumption related features */ + UserAssumptionAccess = 'user_assumption_access', + /** Hard limit for the number of v3 projects a user can own */ + V3MaxProjectLimit = 'v3_max_project_limit', + /** Hard limit for the number of v3 tunnels a user can own */ + V3MaxTunnelLimit = 'v3_max_tunnel_limit', } /** Boolean expression to compare columns of type "user_entitlement_types_enum". All fields are combined with logical 'AND'. */ @@ -75224,6 +78674,89 @@ export type User_Profile_Updates = { where: User_Profile_Bool_Exp; }; +/** This view is created to query all the projects a user is associated to. */ +export type User_Project_Map = { + __typename?: 'user_project_map'; + /** An object relationship */ + project?: Maybe; + project_id?: Maybe; + user_id?: Maybe; +}; + +/** aggregated selection of "user_project_map" */ +export type User_Project_Map_Aggregate = { + __typename?: 'user_project_map_aggregate'; + aggregate?: Maybe; + nodes: Array; +}; + +/** aggregate fields of "user_project_map" */ +export type User_Project_Map_Aggregate_Fields = { + __typename?: 'user_project_map_aggregate_fields'; + count: Scalars['Int']; + max?: Maybe; + min?: Maybe; +}; + +/** aggregate fields of "user_project_map" */ +export type User_Project_Map_Aggregate_FieldsCountArgs = { + columns?: Maybe>; + distinct?: Maybe; +}; + +/** Boolean expression to filter rows from the table "user_project_map". All fields are combined with a logical 'AND'. */ +export type User_Project_Map_Bool_Exp = { + _and?: Maybe>; + _not?: Maybe; + _or?: Maybe>; + project?: Maybe; + project_id?: Maybe; + user_id?: Maybe; +}; + +/** aggregate max on columns */ +export type User_Project_Map_Max_Fields = { + __typename?: 'user_project_map_max_fields'; + project_id?: Maybe; + user_id?: Maybe; +}; + +/** aggregate min on columns */ +export type User_Project_Map_Min_Fields = { + __typename?: 'user_project_map_min_fields'; + project_id?: Maybe; + user_id?: Maybe; +}; + +/** Ordering options when selecting data from "user_project_map". */ +export type User_Project_Map_Order_By = { + project?: Maybe; + project_id?: Maybe; + user_id?: Maybe; +}; + +/** select columns of table "user_project_map" */ +export enum User_Project_Map_Select_Column { + /** column name */ + ProjectId = 'project_id', + /** column name */ + UserId = 'user_id', +} + +/** Streaming cursor of the table "user_project_map" */ +export type User_Project_Map_Stream_Cursor_Input = { + /** Stream column input with initial value */ + initial_value: User_Project_Map_Stream_Cursor_Value_Input; + /** cursor ordering */ + ordering?: Maybe; +}; + +/** Initial value of the column from where the streaming should start */ +export type User_Project_Map_Stream_Cursor_Value_Input = { + project_id?: Maybe; + user_id?: Maybe; +}; + /** Users roles */ export type User_Roles = { __typename?: 'user_roles'; @@ -77394,6 +80927,7 @@ export type Vpc_Peering = { aws_customer_vpc_cidr?: Maybe; aws_customer_vpc_id?: Maybe; aws_customer_vpc_region?: Maybe; + azure_input?: Maybe; comments?: Maybe; created_at: Scalars['timestamptz']; /** An object relationship */ @@ -77415,6 +80949,11 @@ export type Vpc_Peering = { updated_at: Scalars['timestamptz']; }; +/** Peering connections for a dedicated VPC */ +export type Vpc_PeeringAzure_InputArgs = { + path?: Maybe; +}; + /** Peering connections for a dedicated VPC */ export type Vpc_PeeringOutput_VariablesArgs = { path?: Maybe; @@ -77477,6 +81016,7 @@ export type Vpc_Peering_Aggregate_Order_By = { /** append existing jsonb value of filtered columns with new jsonb value */ export type Vpc_Peering_Append_Input = { + azure_input?: Maybe; output_variables?: Maybe; }; @@ -77497,6 +81037,7 @@ export type Vpc_Peering_Bool_Exp = { aws_customer_vpc_cidr?: Maybe; aws_customer_vpc_id?: Maybe; aws_customer_vpc_region?: Maybe; + azure_input?: Maybe; comments?: Maybe; created_at?: Maybe; dedicated_vpc?: Maybe; @@ -77524,6 +81065,7 @@ export enum Vpc_Peering_Constraint { /** delete the field or element with specified path (for JSON arrays, negative integers count from the end) */ export type Vpc_Peering_Delete_At_Path_Input = { + azure_input?: Maybe>; output_variables?: Maybe>; }; @@ -77532,11 +81074,13 @@ export type Vpc_Peering_Delete_At_Path_Input = { * end). throws an error if top level container is not an array */ export type Vpc_Peering_Delete_Elem_Input = { + azure_input?: Maybe; output_variables?: Maybe; }; /** delete key/value pair or string element. key/value pairs are matched based on their key value */ export type Vpc_Peering_Delete_Key_Input = { + azure_input?: Maybe; output_variables?: Maybe; }; @@ -77696,6 +81240,7 @@ export type Vpc_Peering_Insert_Input = { aws_customer_vpc_cidr?: Maybe; aws_customer_vpc_id?: Maybe; aws_customer_vpc_region?: Maybe; + azure_input?: Maybe; comments?: Maybe; created_at?: Maybe; dedicated_vpc?: Maybe; @@ -77809,6 +81354,7 @@ export type Vpc_Peering_Order_By = { aws_customer_vpc_cidr?: Maybe; aws_customer_vpc_id?: Maybe; aws_customer_vpc_region?: Maybe; + azure_input?: Maybe; comments?: Maybe; created_at?: Maybe; dedicated_vpc?: Maybe; @@ -77835,6 +81381,7 @@ export type Vpc_Peering_Pk_Columns_Input = { /** prepend existing jsonb value of filtered columns with new jsonb value */ export type Vpc_Peering_Prepend_Input = { + azure_input?: Maybe; output_variables?: Maybe; }; @@ -77851,6 +81398,8 @@ export enum Vpc_Peering_Select_Column { /** column name */ AwsCustomerVpcRegion = 'aws_customer_vpc_region', /** column name */ + AzureInput = 'azure_input', + /** column name */ Comments = 'comments', /** column name */ CreatedAt = 'created_at', @@ -77907,6 +81456,7 @@ export type Vpc_Peering_Set_Input = { aws_customer_vpc_cidr?: Maybe; aws_customer_vpc_id?: Maybe; aws_customer_vpc_region?: Maybe; + azure_input?: Maybe; comments?: Maybe; created_at?: Maybe; dedicated_vpc_id?: Maybe; @@ -77941,6 +81491,7 @@ export type Vpc_Peering_Stream_Cursor_Value_Input = { aws_customer_vpc_cidr?: Maybe; aws_customer_vpc_id?: Maybe; aws_customer_vpc_region?: Maybe; + azure_input?: Maybe; comments?: Maybe; created_at?: Maybe; dedicated_vpc_id?: Maybe; @@ -77973,6 +81524,8 @@ export enum Vpc_Peering_Update_Column { /** column name */ AwsCustomerVpcRegion = 'aws_customer_vpc_region', /** column name */ + AzureInput = 'azure_input', + /** column name */ Comments = 'comments', /** column name */ CreatedAt = 'created_at', @@ -78901,3 +82454,20 @@ export type AddSchemaRegistryFeatureRequestMutation = { status: string; } | null; }; + +export type FetchConfigStatusSubscriptionVariables = Exact<{ + tenantId: Scalars['uuid']; +}>; + +export type FetchConfigStatusSubscription = { + __typename?: 'subscription_root'; + hasura_worker: Array<{ + __typename?: 'hasura_worker'; + config_statuses: Array<{ + __typename?: 'config_status'; + hash: string; + message?: string | null; + worker_id: any; + }>; + }>; +}; diff --git a/frontend/libs/console/legacy-ce/src/lib/features/ControlPlane/queries.ts b/frontend/libs/console/legacy-ce/src/lib/features/ControlPlane/queries.ts index 3ae44011356..a23da228f17 100644 --- a/frontend/libs/console/legacy-ce/src/lib/features/ControlPlane/queries.ts +++ b/frontend/libs/console/legacy-ce/src/lib/features/ControlPlane/queries.ts @@ -265,15 +265,12 @@ export const ADD_SCHEMA_REGISTRY_FEATURE_REQUEST = gql(` `); export const FETCH_CONFIG_STATUS = gql(` - subscription FetchConfigStatus($tenantId: uuid!) { - config_status( - where: { - tenant_id: { _eq: $tenantId } - is_active: { _eq: true } - } - ) { +subscription FetchConfigStatus($tenantId: uuid!) { + hasura_worker(where: {config_statuses: {is_active: {_eq: true}, tenant_id: {_eq: $tenantId}}, status: {_eq: "live"}}) { + config_statuses(where: {is_active: {_eq: true}, tenant_id: {_eq: $tenantId}}) { hash message + worker_id } } -`); +}`);