@amplitude/ampli/lib/graphql/generated/index.d.ts

Amplitude CLI

import { GraphQLClient } from 'graphql-request';
export declare type Maybe<T> = T | null;
export declare type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export declare type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    DateTime: any;
    JSON: any;
};
export declare type Activity = {
    __typename?: 'Activity';
    id: Scalars['ID'];
    versionId?: Maybe<Scalars['ID']>;
    time: Scalars['String'];
    user: User;
    type: Scalars['String'];
    event?: Maybe<Event>;
    template?: Maybe<Template>;
    property?: Maybe<Property>;
    source?: Maybe<Source>;
    destination?: Maybe<Destination>;
    data: Scalars['JSON'];
    version?: Maybe<Version>;
    groupType?: Maybe<GroupType>;
};
export declare enum ActivityAction {
    Added = "Added",
    Deleted = "Deleted",
    Updated = "Updated"
}
export declare type ActivityConnection = {
    __typename?: 'ActivityConnection';
    edges: Array<ActivityEdge>;
    pageInfo: PageInfo;
};
export declare type ActivityEdge = {
    __typename?: 'ActivityEdge';
    cursor: Scalars['String'];
    node: Activity;
};
export declare enum ActivityEntity {
    Branch = "Branch",
    Comment = "Comment",
    Destination = "Destination",
    Environment = "Environment",
    EventSourceDestination = "EventSourceDestination",
    Event = "Event",
    Property = "Property",
    PullRequest = "PullRequest",
    PullRequestReview = "PullRequestReview",
    ScheduledAction = "ScheduledAction",
    ScheduledActionVote = "ScheduledActionVote",
    Setting = "Setting",
    Template = "Template",
    Version = "Version",
    Workspace = "Workspace"
}
export declare type ActivityFilter = {
    entities?: Maybe<Array<ActivityEntity>>;
    actions?: Maybe<Array<ActivityAction>>;
    loginIds?: Maybe<Array<Scalars['String']>>;
};
export declare type AddUnexpectedEventsAnalytics = {
    observeComponent: CreateEventAnalyticsObserveComponent;
};
export declare type AllowedValue = {
    __typename?: 'AllowedValue';
    name?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};
export declare type AnalyticsSdk = {
    __typename?: 'AnalyticsSDK';
    browserSDK?: Maybe<Scalars['JSON']>;
};
export declare type ApiToken = {
    __typename?: 'ApiToken';
    id: Scalars['ID'];
    name: Scalars['String'];
    code?: Maybe<Scalars['String']>;
    user: User;
    dateCreated: Scalars['DateTime'];
};
export declare type App = {
    __typename?: 'App';
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    isWarehouseNative?: Maybe<Scalars['Boolean']>;
    apiKey?: Maybe<Scalars['String']>;
    suggestions: Array<Suggestion>;
    suggestionsScore: SuggestionsScore;
    classificationCounts: Array<ClassificationCounts>;
};
export declare type AppSuggestionsArgs = {
    branchName?: Maybe<Scalars['String']>;
    wizard?: Maybe<Scalars['String']>;
    entityName?: Maybe<Scalars['String']>;
    product?: Maybe<Product>;
};
export declare type AppSuggestionsScoreArgs = {
    branchName?: Maybe<Scalars['String']>;
    product?: Maybe<Product>;
};
export declare type ApplySuggestionInput = {
    id: Scalars['ID'];
    values?: Maybe<Array<Scalars['String']>>;
};
export declare type Branch = {
    __typename?: 'Branch';
    id: Scalars['ID'];
    name: Scalars['String'];
    description: Scalars['String'];
    currentVersionId: Scalars['ID'];
    stagingVersionId: Scalars['ID'];
    default: Scalars['Boolean'];
    versions: Array<Version>;
};
export declare type BranchVersionsArgs = {
    id?: Maybe<Scalars['ID']>;
    dateStart?: Maybe<Scalars['DateTime']>;
    dateEnd?: Maybe<Scalars['DateTime']>;
    environmentId?: Maybe<Scalars['ID']>;
    branchName?: Maybe<Scalars['String']>;
};
export declare type BulkEditSettingsInput = {
    workspaceIds: Array<Scalars['ID']>;
    settings: Array<SettingInput>;
};
export declare type ClassificationCounts = {
    __typename?: 'ClassificationCounts';
    classification: Scalars['String'];
    eventPropertyCount: Scalars['Int'];
    userPropertyCount: Scalars['Int'];
    groupPropertyCount: Scalars['Int'];
};
export declare type Comment = {
    __typename?: 'Comment';
    id: Scalars['ID'];
    user: User;
    description: Scalars['String'];
    dateCreated: Scalars['DateTime'];
    dateModified?: Maybe<Scalars['DateTime']>;
    active: Scalars['Boolean'];
};
export declare enum ComparisonResult {
    NoChanges = "noChanges",
    Added = "added",
    Removed = "removed",
    Updated = "updated",
    Conflict = "conflict"
}
export declare enum CompatibilityLevel {
    Full = "full",
    Model = "model",
    Addition = "addition"
}
export declare type ConflictResolutionInput = {
    id: Scalars['ID'];
    side: ConflictResolutionSide;
};
export declare enum ConflictResolutionSide {
    Origin = "origin",
    Target = "target"
}
export declare type CreateApiTokenInput = {
    workspaceId: Scalars['ID'];
};
export declare type CreateBranchInput = {
    workspaceId: Scalars['ID'];
    branchedOffBranchId: Scalars['ID'];
    name: Scalars['String'];
    description?: Maybe<Scalars['String']>;
};
export declare type CreateCommentInput = {
    workspaceId: Scalars['ID'];
    description: Scalars['String'];
    event?: Maybe<MapEventCommentInput>;
    template?: Maybe<MapTemplateCommentInput>;
    property?: Maybe<MapPropertyCommentInput>;
};
export declare type CreateDestinationInput = {
    versionId: Scalars['ID'];
    input: DestinationInput;
};
export declare type CreateEnvironmentInput = {
    name: Scalars['String'];
    rank: Scalars['Int'];
    appId?: Maybe<Scalars['ID']>;
};
export declare type CreateEventAnalytics = {
    method: CreateEventAnalyticsMethod;
    observeComponent?: Maybe<CreateEventAnalyticsObserveComponent>;
    suggestionUsed?: Maybe<Scalars['Boolean']>;
};
export declare enum CreateEventAnalyticsMethod {
    Observe = "Observe",
    New = "New",
    Copy = "Copy",
    Csv = "CSV",
    Migration = "Migration"
}
export declare enum CreateEventAnalyticsObserveComponent {
    TableToolbar = "tableToolbar",
    DetailsPaneKabob = "detailsPaneKabob",
    DetailsPaneCta = "detailsPaneCta",
    TableStatusTooltip = "tableStatusTooltip",
    TableActionColumn = "tableActionColumn",
    TrackingPlanAudit = "trackingPlanAudit"
}
export declare type CreateEventInput = {
    versionId: Scalars['ID'];
    name: Scalars['String'];
    description?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    ownerId?: Maybe<Scalars['String']>;
    category?: Maybe<Scalars['String']>;
    isActiveAction?: Maybe<Scalars['Boolean']>;
    isDeleted?: Maybe<Scalars['Boolean']>;
    isHiddenFromClusters?: Maybe<Scalars['Boolean']>;
    isHiddenFromDropdowns?: Maybe<Scalars['Boolean']>;
    isHiddenFromPathfinder?: Maybe<Scalars['Boolean']>;
    isHiddenFromTimeline?: Maybe<Scalars['Boolean']>;
    isPlanned?: Maybe<Scalars['Boolean']>;
    sources?: Maybe<Array<MapSourceInput>>;
    properties?: Maybe<Array<CreatePropertyInput>>;
    templates?: Maybe<Array<MapTemplateInput>>;
    tags?: Maybe<Array<ModifyTagsInput>>;
    classifications?: Maybe<Array<Scalars['String']>>;
};
export declare type CreateEventPropertyInput = {
    versionId: Scalars['ID'];
    eventId: Scalars['ID'];
    input: CreatePropertyInput;
};
export declare type CreateEventPropertyOverrideInput = {
    versionId: Scalars['ID'];
    eventId: Scalars['ID'];
    input: CreateOverridePropertyInput;
};
export declare type CreateGroupTypePropertyInput = {
    versionId: Scalars['ID'];
    groupTypeId: Scalars['ID'];
    input: CreatePropertyInput;
};
export declare type CreateHermesSlackIntegrationInput = {
    workspaceId: Scalars['ID'];
    conversationId: Scalars['String'];
};
export declare type CreateJiraCommentInput = {
    workspaceId: Scalars['ID'];
    branchId: Scalars['ID'];
    sourceIds: Array<Scalars['ID']>;
};
export declare type CreateJiraTicketInput = {
    workspaceId: Scalars['ID'];
    branchId: Scalars['ID'];
    sourceId: Scalars['ID'];
    fields: Array<CreateTicketField>;
};
export declare type CreateOverridePropertyInput = {
    propertyId: Scalars['ID'];
    versionId: Scalars['ID'];
    kind: PropertyKind;
    name: Scalars['String'];
    type: Scalars['String'];
    typeTemplateId?: Maybe<Scalars['ID']>;
    required: Scalars['Boolean'];
    origin?: Maybe<PropertyOrigin>;
    description?: Maybe<Scalars['String']>;
    isDeleted?: Maybe<Scalars['Boolean']>;
    example?: Maybe<Scalars['String']>;
    schema?: Maybe<Scalars['JSON']>;
    isHidden?: Maybe<Scalars['Boolean']>;
    displayName?: Maybe<Scalars['String']>;
    classifications?: Maybe<Array<Scalars['String']>>;
};
export declare type CreateOverrideTemplatePropertyInput = {
    versionId: Scalars['ID'];
    templateId: Scalars['ID'];
    input: CreateOverridePropertyInput;
};
export declare type CreatePropertyAnalytics = {
    method?: Maybe<CreatePropertyAnalyticsMethod>;
    suggestionUsed?: Maybe<Scalars['Boolean']>;
};
export declare enum CreatePropertyAnalyticsMethod {
    Observe = "Observe",
    New = "New",
    Copy = "Copy",
    Csv = "CSV",
    Migration = "Migration"
}
export declare type CreatePropertyInput = {
    versionId: Scalars['ID'];
    kind: PropertyKind;
    name: Scalars['String'];
    type: Scalars['String'];
    typeTemplateId?: Maybe<Scalars['ID']>;
    required: Scalars['Boolean'];
    origin?: Maybe<PropertyOrigin>;
    description?: Maybe<Scalars['String']>;
    isDeleted?: Maybe<Scalars['Boolean']>;
    example?: Maybe<Scalars['String']>;
    schema?: Maybe<Scalars['JSON']>;
    isHidden?: Maybe<Scalars['Boolean']>;
    planStatus?: Maybe<PropertyPlanStatus>;
    displayName?: Maybe<Scalars['String']>;
    classifications?: Maybe<Array<Scalars['String']>>;
};
export declare type CreatePublicDocInput = {
    workspaceId: Scalars['ID'];
};
export declare type CreatePullRequestInput = {
    workspaceId: Scalars['ID'];
    originBranchId: Scalars['ID'];
    targetBranchId: Scalars['ID'];
    status?: Maybe<PullRequestStatus>;
    description?: Maybe<Scalars['String']>;
};
export declare type CreatePullRequestReviewInput = {
    pullRequestId: Scalars['ID'];
    status: PullRequestReviewStatus;
};
export declare type CreateScheduledActionInput = {
    workspaceId: Scalars['ID'];
    eventType: Scalars['String'];
    type: ScheduledActionType;
    daysFromNow: Scalars['Int'];
    cancelationVoteCount: Scalars['Int'];
    recipients?: Maybe<Array<Scalars['String']>>;
};
export declare type CreateScheduledActionVoteForAppInput = {
    appId: Scalars['ID'];
    eventType: Scalars['String'];
    note?: Maybe<Scalars['String']>;
};
export declare type CreateScheduledActionVoteInput = {
    workspaceId: Scalars['ID'];
    eventType: Scalars['String'];
    note?: Maybe<Scalars['String']>;
};
export declare type CreateSlackIntegrationInput = {
    workspaceId: Scalars['ID'];
    channel?: Maybe<Scalars['String']>;
    webhookUrl: Scalars['String'];
};
export declare type CreateSourceInput = {
    versionId: Scalars['ID'];
    name: Scalars['String'];
    description?: Maybe<Scalars['String']>;
    color: Scalars['String'];
    icon?: Maybe<Scalars['String']>;
    runtimeId: Scalars['ID'];
    destinations?: Maybe<Array<SourceDestinationInput>>;
    templates?: Maybe<Array<ModifyTemplatesInput>>;
};
export declare type CreateTemplateInput = {
    versionId: Scalars['ID'];
    name: Scalars['String'];
    description?: Maybe<Scalars['String']>;
    properties?: Maybe<Array<CreatePropertyInput>>;
    tags?: Maybe<Array<ModifyTagsInput>>;
};
export declare type CreateTemplatePropertyInput = {
    versionId: Scalars['ID'];
    templateId: Scalars['ID'];
    input: CreatePropertyInput;
};
export declare type CreateTicketField = {
    key: Scalars['String'];
    id?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
    schema: TicketFieldSchema;
};
export declare type CreateWorkspaceInput = {
    orgId: Scalars['ID'];
    name: Scalars['String'];
    environments: Array<CreateEnvironmentInput>;
    skipImport?: Maybe<Scalars['Boolean']>;
    skipCompletionCheck?: Maybe<Scalars['Boolean']>;
};
export declare enum DataSuggestionWizard {
    AbsentNamingConvention = "AbsentNamingConvention",
    EmptyEventDescription = "EmptyEventDescription",
    EmptyEventCategory = "EmptyEventCategory",
    EmptyEventOwner = "EmptyEventOwner",
    ConventionalEventDisplayName = "ConventionalEventDisplayName",
    EventVolumeAnomaly = "EventVolumeAnomaly",
    OneOffEvent = "OneOffEvent",
    ZeroQueryEvent = "ZeroQueryEvent",
    StaleBranch = "StaleBranch",
    NewUnexpectedEvent = "NewUnexpectedEvent",
    DynamicEventDefinitionFix = "DynamicEventDefinitionFix",
    SuggestedCustomEventFromBlock = "SuggestedCustomEventFromBlock",
    SuggestedAutotagEvent = "SuggestedAutotagEvent"
}
export declare type DeleteApiTokenInput = {
    id: Scalars['ID'];
};
export declare type DeleteBranchInput = {
    id: Scalars['ID'];
};
export declare type DeleteCommentInput = {
    id: Scalars['ID'];
};
export declare type DeleteDestinationInput = {
    id: Scalars['ID'];
    versionId: Scalars['ID'];
};
export declare type DeleteEventAnalytics = {
    method: DeleteEventAnalyticsMethod;
};
export declare enum DeleteEventAnalyticsMethod {
    DetailPane = "detailPane",
    EventList = "eventList",
    Csv = "CSV"
}
export declare type DeleteEventsInput = {
    workspaceId: Scalars['ID'];
    environmentId?: Maybe<Scalars['ID']>;
    branchName: Scalars['ID'];
    eventTypes: Array<Scalars['String']>;
    eventVersionIds?: Maybe<Array<Scalars['String']>>;
    eventQueryIds?: Maybe<Array<Scalars['String']>>;
};
export declare type DeleteEventsResult = {
    __typename?: 'DeleteEventsResult';
    deletedEvents: Array<Scalars['String']>;
    notFoundEvents: Array<Scalars['String']>;
};
export declare type DeleteHermesSlackIntegrationInput = {
    workspaceId: Scalars['ID'];
};
export declare type DeleteJiraIntegrationInput = {
    workspaceId: Scalars['ID'];
};
export declare type DeleteJiraTicketInput = {
    id: Scalars['ID'];
    workspaceId: Scalars['ID'];
    branchId: Scalars['ID'];
    sourceId: Scalars['ID'];
};
export declare type DeletePublicDocInput = {
    workspaceId: Scalars['ID'];
};
export declare type DeletePullRequestInput = {
    id: Scalars['ID'];
};
export declare type DeleteRestoreEventPropertiesInput = {
    versionId: Scalars['ID'];
    propertyIds: Array<Scalars['ID']>;
    eventId?: Maybe<Scalars['ID']>;
};
export declare type DeleteRestoreEventPropertiesResult = {
    __typename?: 'DeleteRestoreEventPropertiesResult';
    localProperties: Array<Property>;
    globalProperties: Array<Property>;
};
export declare type DeleteRestorePropertyInput = {
    versionId: Scalars['ID'];
    kind: PropertyKind;
    names: Array<Scalars['String']>;
};
export declare type DeleteScheduledActionInput = {
    id: Scalars['ID'];
    workspaceId: Scalars['ID'];
};
export declare type DeleteScheduledActionResult = {
    __typename?: 'DeleteScheduledActionResult';
    id: Scalars['ID'];
    eventType: Scalars['String'];
};
export declare type DeleteScheduledActionVoteForAppInput = {
    appId: Scalars['ID'];
    eventType: Scalars['String'];
};
export declare type DeleteScheduledActionVoteInput = {
    workspaceId: Scalars['ID'];
    eventType: Scalars['String'];
};
export declare type DeleteScheduledActionVoteResult = {
    __typename?: 'DeleteScheduledActionVoteResult';
    id: Scalars['ID'];
    eventType: Scalars['String'];
};
export declare type DeleteSlackIntegrationInput = {
    workspaceId: Scalars['ID'];
};
export declare type DeleteSourceInput = {
    id: Scalars['ID'];
    versionId: Scalars['ID'];
};
export declare type DeleteTemplateInput = {
    id: Scalars['ID'];
    versionId: Scalars['ID'];
};
export declare type DeleteWorkspaceInput = {
    id: Scalars['ID'];
};
export declare type Destination = {
    __typename?: 'Destination';
    id: Scalars['ID'];
    serviceId: DestinationServiceType;
    sources: Array<Maybe<Source>>;
    apiKeys: Array<DestinationApiKey>;
    enabledByDefault: Scalars['Boolean'];
    name: Scalars['String'];
    pluginId: Scalars['String'];
};
export declare type DestinationApiKey = {
    __typename?: 'DestinationApiKey';
    id: Scalars['ID'];
    environment: Environment;
    apiKey: Scalars['String'];
};
export declare type DestinationApiKeyInput = {
    environment: Scalars['String'];
    apiKey: Scalars['String'];
};
export declare type DestinationInput = {
    serviceId: DestinationServiceType;
    sources: Array<DestinationSourceInput>;
    apiKeys: Array<DestinationApiKeyInput>;
    enabledByDefault: Scalars['Boolean'];
    name: Scalars['String'];
    pluginId: Scalars['ID'];
};
export declare enum DestinationServiceType {
    Amplitude = "amplitude",
    Custom = "custom",
    Mixpanel = "mixpanel",
    Segment = "segment",
    Snowplow = "snowplow",
    Mparticle = "mparticle",
    Firebase = "firebase"
}
export declare type DestinationSourceInput = {
    id: Scalars['ID'];
    active: Scalars['Boolean'];
};
export declare type EditBranchInput = {
    id: Scalars['ID'];
    name: Scalars['String'];
    description?: Maybe<Scalars['String']>;
};
export declare type EditCommentInput = {
    id: Scalars['ID'];
    description: Scalars['String'];
};
export declare type EditCompanyInput = {
    name: Scalars['String'];
};
export declare type EditDestinationInput = {
    id: Scalars['ID'];
    versionId: Scalars['ID'];
    input: DestinationInput;
};
export declare type EditEventAnalytics = {
    method?: Maybe<EditEventAnalyticsMethod>;
    component?: Maybe<EditEventAnalyticsComponent>;
    suggestionUsed?: Maybe<Scalars['Boolean']>;
};
export declare enum EditEventAnalyticsComponent {
    Table = "Table",
    DetailsPane = "DetailsPane",
    TableActionToolbar = "TableActionToolbar",
    Csv = "CSV",
    Migration = "Migration"
}
export declare enum EditEventAnalyticsMethod {
    Csv = "CSV",
    Copy = "Copy",
    Migration = "Migration",
    New = "New",
    Observe = "Observe"
}
export declare type EditEventInput = {
    id: Scalars['ID'];
    versionId: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    category?: Maybe<Scalars['String']>;
    isActiveAction?: Maybe<Scalars['Boolean']>;
    isDeleted?: Maybe<Scalars['Boolean']>;
    isHiddenFromClusters?: Maybe<Scalars['Boolean']>;
    isHiddenFromDropdowns?: Maybe<Scalars['Boolean']>;
    isHiddenFromPathfinder?: Maybe<Scalars['Boolean']>;
    isHiddenFromTimeline?: Maybe<Scalars['Boolean']>;
    isPlanned?: Maybe<Scalars['Boolean']>;
    ownerId?: Maybe<Scalars['ID']>;
    sources?: Maybe<Array<ModifySourcesInput>>;
    templates?: Maybe<Array<ModifyTemplatesInput>>;
    tags?: Maybe<Array<ModifyTagsInput>>;
    sourceDestinations?: Maybe<Array<ModifySourceDestinationsInput>>;
    classifications?: Maybe<Array<Scalars['String']>>;
};
export declare type EditEventStatusInput = {
    branchId: Scalars['ID'];
    versionId: Scalars['ID'];
    eventId: Scalars['ID'];
    sourceId: Scalars['ID'];
    status: InstrumentationStatus;
    input: Array<EventStatusInput>;
};
export declare type EditEventV2Input = {
    eventType: Scalars['String'];
    versionId: Scalars['ID'];
    newName?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    category?: Maybe<Scalars['String']>;
    isActiveAction?: Maybe<Scalars['Boolean']>;
    isDeleted?: Maybe<Scalars['Boolean']>;
    isHiddenFromClusters?: Maybe<Scalars['Boolean']>;
    isHiddenFromDropdowns?: Maybe<Scalars['Boolean']>;
    isHiddenFromPathfinder?: Maybe<Scalars['Boolean']>;
    isHiddenFromTimeline?: Maybe<Scalars['Boolean']>;
    isPlanned?: Maybe<Scalars['Boolean']>;
    ownerId?: Maybe<Scalars['ID']>;
    sources?: Maybe<Array<ModifySourcesInput>>;
    templates?: Maybe<Array<ModifyTemplatesInput>>;
    tags?: Maybe<Array<ModifyTagsInput>>;
    sourceDestinations?: Maybe<Array<ModifySourceDestinationsInput>>;
    classifications?: Maybe<Array<Scalars['String']>>;
};
export declare type EditHermesSlackIntegrationInput = {
    workspaceId: Scalars['ID'];
    conversationId: Scalars['String'];
};
export declare type EditPropertyAnalytics = {
    method?: Maybe<EditPropertyAnalyticsMethod>;
    component?: Maybe<EditPropertyAnalyticsComponent>;
    suggestionUsed?: Maybe<Scalars['Boolean']>;
};
export declare enum EditPropertyAnalyticsComponent {
    Table = "Table",
    DetailsPane = "DetailsPane",
    TableActionToolbar = "TableActionToolbar",
    Csv = "CSV",
    Migration = "Migration"
}
export declare enum EditPropertyAnalyticsMethod {
    Csv = "CSV",
    Copy = "Copy",
    Migration = "Migration",
    New = "New",
    Observe = "Observe"
}
export declare type EditPropertyInput = {
    id: Scalars['ID'];
    versionId: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    example?: Maybe<Scalars['String']>;
    isDeleted?: Maybe<Scalars['Boolean']>;
    required?: Maybe<Scalars['Boolean']>;
    type?: Maybe<Scalars['String']>;
    typeTemplateId?: Maybe<Scalars['ID']>;
    schema?: Maybe<Scalars['JSON']>;
    isHidden?: Maybe<Scalars['Boolean']>;
    eventId?: Maybe<Scalars['ID']>;
    templateId?: Maybe<Scalars['ID']>;
    groupTypeId?: Maybe<Scalars['ID']>;
    displayName?: Maybe<Scalars['String']>;
    classifications?: Maybe<Array<Scalars['String']>>;
    planStatus?: Maybe<PropertyPlanStatus>;
};
export declare type EditPullRequestInput = {
    id: Scalars['ID'];
    status?: Maybe<PullRequestStatus>;
    description?: Maybe<Scalars['String']>;
};
export declare type EditScheduledActionInput = {
    id: Scalars['ID'];
    workspaceId: Scalars['ID'];
    eventType: Scalars['String'];
    type: ScheduledActionType;
    daysFromNow: Scalars['Int'];
    cancelationVoteCount: Scalars['Int'];
};
export declare type EditSettingsInput = {
    workspaceId: Scalars['ID'];
    settings: Array<SettingInput>;
};
export declare type EditSlackIntegrationInput = {
    workspaceId: Scalars['ID'];
    channel?: Maybe<Scalars['String']>;
    webhookUrl?: Maybe<Scalars['String']>;
};
export declare type EditSourceInput = {
    id: Scalars['ID'];
    versionId: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    color?: Maybe<Scalars['String']>;
    icon?: Maybe<Scalars['String']>;
    runtimeId?: Maybe<Scalars['ID']>;
    destinations?: Maybe<Array<SourceDestinationInput>>;
    templates?: Maybe<Array<ModifyTemplatesInput>>;
};
export declare type EditTemplateInput = {
    id: Scalars['ID'];
    versionId: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    ownerId?: Maybe<Scalars['ID']>;
    tags?: Maybe<Array<ModifyTagsInput>>;
};
export declare type EditWorkspaceInput = {
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    environments?: Maybe<Array<ModifyEnvironmentInput>>;
};
export declare type Environment = {
    __typename?: 'Environment';
    id: Scalars['ID'];
    name: Scalars['String'];
    app?: Maybe<App>;
    rank: Scalars['Int'];
};
export declare type Event = {
    __typename?: 'Event';
    id: Scalars['ID'];
    versionId: Scalars['ID'];
    name: Scalars['String'];
    dateCreated: Scalars['DateTime'];
    description: Scalars['String'];
    displayName: Scalars['String'];
    category: Scalars['String'];
    isActiveAction: Scalars['Boolean'];
    isDeleted: Scalars['Boolean'];
    isHiddenFromClusters: Scalars['Boolean'];
    isHiddenFromDropdowns: Scalars['Boolean'];
    isHiddenFromPathfinder: Scalars['Boolean'];
    isHiddenFromTimeline: Scalars['Boolean'];
    isPlanned: Scalars['Boolean'];
    user?: Maybe<User>;
    templates: Array<Template>;
    properties: Array<Property>;
    sources: Array<Source>;
    statuses: Array<EventStatus>;
    tags: Array<Tag>;
    unifiedSchema: EventSchema;
    activities: ActivityConnection;
    active: Scalars['Boolean'];
    sourceDestinations: Array<EventSourceDestination>;
    hasSharedProperty: Scalars['Boolean'];
    classifications: Array<Scalars['String']>;
};
export declare type EventPropertiesArgs = {
    propertyId?: Maybe<Scalars['ID']>;
};
export declare type EventStatusesArgs = {
    branchId?: Maybe<Scalars['ID']>;
};
export declare type EventActivitiesArgs = {
    pagingInput?: Maybe<PagingInput>;
};
export declare type EventSourceDestinationsArgs = {
    sourceIds: Array<Scalars['ID']>;
};
export declare type EventAnomalies = {
    __typename?: 'EventAnomalies';
    chartStartTimes: Array<Scalars['Float']>;
    chartEndTimes: Array<Scalars['Float']>;
    anomalyStartTimes: Array<Scalars['Float']>;
    anomalyEndTimes: Array<Scalars['Float']>;
    changePercentages: Array<Scalars['Float']>;
};
export declare type EventAuditAggregation = {
    __typename?: 'EventAuditAggregation';
    eventSchemaVersion: Scalars['String'];
    validCount: Scalars['Float'];
    invalidCount: Scalars['Float'];
};
export declare type EventComparison = {
    __typename?: 'EventComparison';
    id: Scalars['ID'];
    result: ComparisonResult;
    compatibility: CompatibilityLevel;
    event: Event;
    objectComparison?: Maybe<EventObjectComparison>;
    propertyComparisons?: Maybe<Array<PropertyComparison>>;
    sourceComparisons?: Maybe<Array<SourceComparison>>;
    sourceDestinationComparisons?: Maybe<Array<SourceDestinationComparison>>;
    templateComparisons?: Maybe<Array<TemplateObjectComparison>>;
    tagComparisons?: Maybe<Array<TagComparison>>;
};
export declare type EventObjectComparison = {
    __typename?: 'EventObjectComparison';
    id: Scalars['ID'];
    result: ComparisonResult;
    compatibility: CompatibilityLevel;
    origin?: Maybe<Event>;
    target?: Maybe<Event>;
};
export declare type EventObserveReport = {
    __typename?: 'EventObserveReport';
    eventCount: Scalars['Float'];
    eventErrorAggregation: Array<Scalars['String']>;
    volumeSeries: VolumeSeries;
    auditAggregations: Array<EventAuditAggregation>;
    eventSourceReports: Array<EventSourceReport>;
    anomalyCount: Scalars['Float'];
    anomalies: EventAnomalies;
};
export declare type EventPropertiesOverride = {
    eventId: Scalars['ID'];
    propertyId: Scalars['ID'];
};
export declare type EventPropertyObserveReport = {
    __typename?: 'EventPropertyObserveReport';
    eventCount: Scalars['Float'];
    auditAggregations: Array<PropertyAuditAggregation>;
};
export declare enum EventPropertyType {
    String = "string",
    Number = "number",
    Boolean = "boolean",
    Enum = "enum",
    Any = "any"
}
export declare type EventSchema = {
    __typename?: 'EventSchema';
    version: Scalars['ID'];
    dateCreated: Scalars['DateTime'];
};
export declare type EventSourceAuditSeriesItem = {
    __typename?: 'EventSourceAuditSeriesItem';
    time: Scalars['Float'];
    eventSchemaVersion: Scalars['String'];
    validCount: Scalars['Float'];
    invalidCount: Scalars['Float'];
};
export declare type EventSourceDestination = {
    __typename?: 'EventSourceDestination';
    event: Event;
    source: Source;
    destination: Destination;
    enabled: Scalars['Boolean'];
};
export declare type EventSourceReport = {
    __typename?: 'EventSourceReport';
    sourceName: Scalars['ID'];
    eventCount: Scalars['Float'];
    auditSeries: Array<EventSourceAuditSeriesItem>;
};
export declare type EventStatus = {
    __typename?: 'EventStatus';
    source: Source;
    status: TrackingStatus;
    instrumentations: Array<Instrumentation>;
};
export declare type EventStatusInstrumentationsArgs = {
    filter?: Maybe<InstrumentationFilter>;
};
export declare type EventStatusInput = {
    path: Scalars['String'];
    row?: Maybe<Scalars['Int']>;
    column?: Maybe<Scalars['Int']>;
};
export declare enum ExperimentSuggestionWizard {
    EmptyExperimentDescription = "EmptyExperimentDescription"
}
export declare type Feature = {
    __typename?: 'Feature';
    id: Scalars['ID'];
    dateCreated: Scalars['DateTime'];
};
export declare type Field = {
    __typename?: 'Field';
    key: Scalars['String'];
    name: Scalars['String'];
    schema: FieldSchema;
    required: Scalars['Boolean'];
    autoCompleteUrl?: Maybe<Scalars['String']>;
    allowedValues?: Maybe<Array<AllowedValue>>;
};
export declare type FieldSchema = {
    __typename?: 'FieldSchema';
    type: Scalars['String'];
    items?: Maybe<Scalars['String']>;
    system?: Maybe<Scalars['String']>;
    custom?: Maybe<Scalars['String']>;
    customId?: Maybe<Scalars['String']>;
};
export declare type ForkBranchInput = {
    id: Scalars['ID'];
    targetWorkspaceId: Scalars['ID'];
};
export declare type GroupType = {
    __typename?: 'GroupType';
    id: Scalars['ID'];
    versionId: Scalars['ID'];
    origin: PropertyOrigin;
    name: Scalars['String'];
    dateCreated: Scalars['DateTime'];
    displayName: Scalars['String'];
    description: Scalars['String'];
    example?: Maybe<Scalars['String']>;
    required: Scalars['Boolean'];
    type: Scalars['String'];
    typeTemplateId?: Maybe<Scalars['ID']>;
    schema: Scalars['JSON'];
    isDeleted: Scalars['Boolean'];
    isHidden: Scalars['Boolean'];
    active: Scalars['Boolean'];
    activities: ActivityConnection;
    properties: Array<Property>;
    isShared: Scalars['Boolean'];
    overridePropertyRevisionId?: Maybe<Scalars['ID']>;
    classifications: Array<Scalars['String']>;
};
export declare type GroupTypeActivitiesArgs = {
    pagingInput?: Maybe<PagingInput>;
};
export declare type GroupTypeComparison = {
    __typename?: 'GroupTypeComparison';
    id: Scalars['ID'];
    result: ComparisonResult;
    compatibility: CompatibilityLevel;
    groupType: GroupType;
    objectComparison?: Maybe<GroupTypeObjectComparison>;
    propertyComparisons?: Maybe<Array<PropertyComparison>>;
};
export declare type GroupTypeObjectComparison = {
    __typename?: 'GroupTypeObjectComparison';
    id: Scalars['ID'];
    result: ComparisonResult;
    compatibility: CompatibilityLevel;
    origin?: Maybe<GroupType>;
    target?: Maybe<GroupType>;
};
export declare type GroupTypePropertiesOverride = {
    groupTypeId: Scalars['ID'];
    groupPropertyId: Scalars['ID'];
};
export declare type HermesSlackIntegration = {
    __typename?: 'HermesSlackIntegration';
    id: Scalars['ID'];
    conversationId: Scalars['String'];
    slackWorkspaceId: Scalars['String'];
};
export declare type Instrumentation = {
    __typename?: 'Instrumentation';
    dateCreated: Scalars['DateTime'];
    status: InstrumentationStatus;
    locations: Array<InstrumentationLocation>;
    schema: EventSchema;
};
export declare enum InstrumentationFilter {
    LastInstrumentation = "lastInstrumentation",
    LastVerification = "lastVerification"
}
export declare type InstrumentationLocation = {
    __typename?: 'InstrumentationLocation';
    path: Scalars['String'];
    row: Scalars['Int'];
    column: Scalars['Int'];
};
export declare enum InstrumentationStatus {
    Instrumented = "instrumented",
    Absent = "absent"
}
export declare type Integration = {
    __typename?: 'Integration';
    slack?: Maybe<SlackIntegration>;
    jira?: Maybe<JiraIntegration>;
    hermesSlack?: Maybe<HermesSlackIntegration>;
};
export declare type InvitedUserInput = {
    emailAddress: Scalars['String'];
};
export declare type Issuetype = {
    __typename?: 'Issuetype';
    id: Scalars['String'];
    name: Scalars['String'];
};
export declare type JiraIntegration = {
    __typename?: 'JiraIntegration';
    id: Scalars['ID'];
    projectId?: Maybe<Scalars['String']>;
    valid: Scalars['Boolean'];
    active: Scalars['Boolean'];
};
export declare type JiraProject = {
    __typename?: 'JiraProject';
    id: Scalars['String'];
    name: Scalars['String'];
};
export declare type LinkJiraTicketInput = {
    workspaceId: Scalars['ID'];
    branchId: Scalars['ID'];
    sourceId: Scalars['ID'];
    ticketId: Scalars['String'];
};
export declare type MapEventCommentInput = {
    versionId: Scalars['ID'];
    eventId: Scalars['ID'];
};
export declare type MapEventPropertyInput = {
    versionId: Scalars['ID'];
    eventId: Scalars['ID'];
    propertyId: Scalars['ID'];
};
export declare type MapGroupTypePropertyInput = {
    versionId: Scalars['ID'];
    groupTypeId: Scalars['ID'];
    groupPropertyId: Scalars['ID'];
};
export declare type MapOverrideEventPropertyInput = {
    versionId: Scalars['ID'];
    eventId: Scalars['ID'];
    propertyId: Scalars['ID'];
    schema?: Maybe<Scalars['JSON']>;
    description?: Maybe<Scalars['String']>;
    required?: Maybe<Scalars['Boolean']>;
    type: Scalars['String'];
    typeTemplateId?: Maybe<Scalars['ID']>;
    example?: Maybe<Scalars['String']>;
    isHidden?: Maybe<Scalars['Boolean']>;
    classifications?: Maybe<Array<Scalars['String']>>;
};
export declare type MapOverrideGroupTypePropertyInput = {
    versionId: Scalars['ID'];
    propertyId: Scalars['ID'];
    groupTypeId: Scalars['ID'];
    schema?: Maybe<Scalars['JSON']>;
    description?: Maybe<Scalars['String']>;
    required?: Maybe<Scalars['Boolean']>;
    type: Scalars['String'];
    typeTemplateId?: Maybe<Scalars['ID']>;
    example?: Maybe<Scalars['String']>;
    isHidden?: Maybe<Scalars['Boolean']>;
    classifications?: Maybe<Array<Scalars['String']>>;
};
export declare type MapOverrideTemplatePropertyInput = {
    versionId: Scalars['ID'];
    propertyId: Scalars['ID'];
    templateId: Scalars['ID'];
    schema?: Maybe<Scalars['JSON']>;
    description?: Maybe<Scalars['String']>;
    required?: Maybe<Scalars['Boolean']>;
    type: Scalars['String'];
    typeTemplateId?: Maybe<Scalars['ID']>;
    example?: Maybe<Scalars['String']>;
    isHidden?: Maybe<Scalars['Boolean']>;
    classifications?: Maybe<Array<Scalars['String']>>;
};
export declare type MapPropertyCommentInput = {
    versionId: Scalars['ID'];
    propertyId: Scalars['ID'];
    eventId?: Maybe<Scalars['ID']>;
    templateId?: Maybe<Scalars['ID']>;
};
export declare type MapSourceInput = {
    id: Scalars['ID'];
};
export declare type MapTemplateCommentInput = {
    versionId: Scalars['ID'];
    templateId: Scalars['ID'];
};
export declare type MapTemplateInput = {
    id: Scalars['ID'];
};
export declare type MapTemplatePropertyInput = {
    versionId: Scalars['ID'];
    templateId: Scalars['ID'];
    propertyId: Scalars['ID'];
};
export declare type MergePullRequestInput = {
    id: Scalars['ID'];
    description?: Maybe<Scalars['String']>;
    conflictResolutions?: Maybe<Array<ConflictResolutionInput>>;
};
export declare type MergedBranchVersion = {
    __typename?: 'MergedBranchVersion';
    branchId: Scalars['String'];
    branchName: Scalars['String'];
    featureSemVer: Scalars['String'];
    featureVersionId: Scalars['String'];
    mainSemVer: Scalars['String'];
    mainVersionId: Scalars['String'];
};
export declare type ModifyEnvironmentInput = {
    id?: Maybe<Scalars['ID']>;
    active?: Maybe<Scalars['Boolean']>;
    name?: Maybe<Scalars['String']>;
    appId?: Maybe<Scalars['ID']>;
    rank?: Maybe<Scalars['Int']>;
    isLegacy?: Maybe<Scalars['Boolean']>;
};
export declare type ModifyEventsInput = {
    id: Scalars['ID'];
    active: Scalars['Boolean'];
};
export declare type ModifySourceDestinationsInput = {
    sourceId: Scalars['ID'];
    destinationId: Scalars['ID'];
    enabled: Scalars['Boolean'];
};
export declare type ModifySourcesInput = {
    id: Scalars['ID'];
    active: Scalars['Boolean'];
};
export declare type ModifyTagsInput = {
    name: Scalars['String'];
    active: Scalars['Boolean'];
};
export declare type ModifyTemplatesInput = {
    id: Scalars['ID'];
    active: Scalars['Boolean'];
};
export declare type Mutation = {
    __typename?: 'Mutation';
    createWorkspace: Workspace;
    editWorkspace: Workspace;
    deleteWorkspaces: Array<Scalars['ID']>;
    createPublicDoc: Scalars['ID'];
    deletePublicDoc: Scalars['ID'];
    updatePublicDoc: Scalars['ID'];
    addUnexpectedEvents: Array<ObservableEvent>;
    createEvents: Array<Event>;
    editEvent: Event;
    editEvents: Array<Event>;
    editEventsV2: Array<ObservableEvent>;
    deleteEvents: DeleteEventsResult;
    restoreEvents: RestoreEventsResult;
    editEventStatus?: Maybe<Scalars['Boolean']>;
    editEventStatuses: Array<Scalars['Boolean']>;
    createTemplate: Template;
    editTemplate: Template;
    deleteTemplates: Array<Scalars['ID']>;
    createProperties: Array<Property>;
    createEventProperty: Property;
    createOverrideEventProperty: Array<Event>;
    updateOverrideEventProperty: Property;
    createEventProperties: Array<Property>;
    createOverrideTemplateProperty: Array<Template>;
    createTemplateProperty: Property;
    createGroupTypeProperties: Array<Property>;
    addGroupTypeProperties: Array<Property>;
    removeGroupTypeProperties: Array<Property>;
    createOverrideGroupTypeProperty: Array<GroupType>;
    revertGroupTypePropertiesOverride: Array<Property>;
    addEventProperties: Array<Event>;
    addTemplateProperties: Array<Template>;
    removeEventProperties: Array<Event>;
    removeTemplateProperties: Array<Template>;
    revertEventPropertiesOverride: Array<Property>;
    revertTemplatePropertiesOverride: Array<Property>;
    editProperty: Property;
    editProperties: Array<Property>;
    removeProperties: Array<Scalars['ID']>;
    removePropertiesNew: RemovePropertiesResult;
    deleteProperties: Array<Property>;
    restoreProperties: Array<Property>;
    deleteEventProperties: DeleteRestoreEventPropertiesResult;
    restoreEventProperties: DeleteRestoreEventPropertiesResult;
    createSource: Source;
    editSource: Source;
    deleteSource?: Maybe<Source>;
    createDestination?: Maybe<Destination>;
    editDestination?: Maybe<Destination>;
    deleteDestination?: Maybe<Destination>;
    editSettings: Array<Setting>;
    bulkEditSettings: Array<Setting>;
    createApiToken: ApiToken;
    deleteApiToken?: Maybe<Scalars['ID']>;
    publishVersion: Branch;
    resetVersion: Branch;
    createBranch: Branch;
    editBranch: Branch;
    deleteBranch: Scalars['ID'];
    forkBranch: Branch;
    createPullRequest: PullRequest;
    editPullRequest: PullRequest;
    deletePullRequest: Scalars['ID'];
    mergePullRequest: PullRequest;
    refreshPullRequest: PullRequest;
    createPullRequestReview: PullRequestReview;
    createSlackIntegration: SlackIntegration;
    editSlackIntegration: SlackIntegration;
    deleteSlackIntegration: SlackIntegration;
    createHermesSlackIntegration: HermesSlackIntegration;
    editHermesSlackIntegration: HermesSlackIntegration;
    deleteHermesSlackIntegration: Scalars['ID'];
    deleteJiraIntegration: Scalars['ID'];
    createJiraTicket: Ticket;
    linkJiraTicket: Ticket;
    createJiraComment: Array<Scalars['Boolean']>;
    deleteJiraTicket: Scalars['ID'];
    createComment: Comment;
    editComment: Comment;
    deleteComments: Array<Scalars['ID']>;
    createScheduledActions: Array<ScheduledAction>;
    deleteScheduledActions: Array<DeleteScheduledActionResult>;
    editScheduledActions: Array<ScheduledAction>;
    createScheduledActionVotes: Array<ScheduledActionVote>;
    createScheduledActionVotesForApp: Array<ScheduledActionVote>;
    deleteScheduledActionVotes: Array<DeleteScheduledActionVoteResult>;
    deleteScheduledActionVotesForApp: Array<Scalars['ID']>;
    applySuggestions: Array<Scalars['ID']>;
    rejectSuggestions: Array<Scalars['ID']>;
    upsertRemoteConfigs?: Maybe<RemoteConfigs>;
};
export declare type MutationCreateWorkspaceArgs = {
    input: CreateWorkspaceInput;
};
export declare type MutationEditWorkspaceArgs = {
    input: EditWorkspaceInput;
};
export declare type MutationDeleteWorkspacesArgs = {
    inputs: Array<DeleteWorkspaceInput>;
};
export declare type MutationCreatePublicDocArgs = {
    input: CreatePublicDocInput;
};
export declare type MutationDeletePublicDocArgs = {
    input: DeletePublicDocInput;
};
export declare type MutationUpdatePublicDocArgs = {
    input: UpdatePublicDocInput;
};
export declare type MutationAddUnexpectedEventsArgs = {
    versionId: Scalars['ID'];
    names: Array<Scalars['String']>;
    isDeleted: Scalars['Boolean'];
    shouldAddProperties: Scalars['Boolean'];
    dateStart: Scalars['DateTime'];
    dateEnd: Scalars['DateTime'];
    environmentId: Scalars['ID'];
    branchName: Scalars['String'];
    analytics: AddUnexpectedEventsAnalytics;
};
export declare type MutationCreateEventsArgs = {
    input: Array<CreateEventInput>;
    analytics?: Maybe<CreateEventAnalytics>;
};
export declare type MutationEditEventArgs = {
    input: EditEventInput;
    analytics?: Maybe<EditEventAnalytics>;
};
export declare type MutationEditEventsArgs = {
    input: Array<EditEventInput>;
    analytics?: Maybe<EditEventAnalytics>;
};
export declare type MutationEditEventsV2Args = {
    input: Array<EditEventV2Input>;
};
export declare type MutationDeleteEventsArgs = {
    input: DeleteEventsInput;
    analytics?: Maybe<DeleteEventAnalytics>;
};
export declare type MutationRestoreEventsArgs = {
    input: RestoreEventsInput;
};
export declare type MutationEditEventStatusArgs = {
    input: EditEventStatusInput;
};
export declare type MutationEditEventStatusesArgs = {
    input: Array<EditEventStatusInput>;
};
export declare type MutationCreateTemplateArgs = {
    input: CreateTemplateInput;
};
export declare type MutationEditTemplateArgs = {
    input: EditTemplateInput;
};
export declare type MutationDeleteTemplatesArgs = {
    input: Array<DeleteTemplateInput>;
};
export declare type MutationCreatePropertiesArgs = {
    input: Array<CreatePropertyInput>;
    analytics?: Maybe<CreatePropertyAnalytics>;
};
export declare type MutationCreateEventPropertyArgs = {
    input: CreateEventPropertyInput;
    analytics?: Maybe<CreatePropertyAnalytics>;
};
export declare type MutationCreateOverrideEventPropertyArgs = {
    input: MapOverrideEventPropertyInput;
};
export declare type MutationUpdateOverrideEventPropertyArgs = {
    input: MapOverrideEventPropertyInput;
};
export declare type MutationCreateEventPropertiesArgs = {
    input: Array<CreateEventPropertyInput>;
    analytics?: Maybe<CreatePropertyAnalytics>;
};
export declare type MutationCreateOverrideTemplatePropertyArgs = {
    input: MapOverrideTemplatePropertyInput;
};
export declare type MutationCreateTemplatePropertyArgs = {
    input: CreateTemplatePropertyInput;
    analytics?: Maybe<CreatePropertyAnalytics>;
};
export declare type MutationCreateGroupTypePropertiesArgs = {
    input: Array<CreateGroupTypePropertyInput>;
    analytics?: Maybe<CreatePropertyAnalytics>;
};
export declare type MutationAddGroupTypePropertiesArgs = {
    input: Array<MapGroupTypePropertyInput>;
};
export declare type MutationRemoveGroupTypePropertiesArgs = {
    input: Array<MapGroupTypePropertyInput>;
};
export declare type MutationCreateOverrideGroupTypePropertyArgs = {
    input: MapOverrideGroupTypePropertyInput;
};
export declare type MutationRevertGroupTypePropertiesOverrideArgs = {
    input: RevertGroupTypePropertiesOverrideInput;
};
export declare type MutationAddEventPropertiesArgs = {
    input: Array<MapEventPropertyInput>;
};
export declare type MutationAddTemplatePropertiesArgs = {
    input: Array<MapTemplatePropertyInput>;
};
export declare type MutationRemoveEventPropertiesArgs = {
    input: Array<MapEventPropertyInput>;
};
export declare type MutationRemoveTemplatePropertiesArgs = {
    input: Array<MapTemplatePropertyInput>;
};
export declare type MutationRevertEventPropertiesOverrideArgs = {
    input: RevertEventPropertiesOverrideInput;
};
export declare type MutationRevertTemplatePropertiesOverrideArgs = {
    input: RevertTemplatePropertiesOverrideInput;
};
export declare type MutationEditPropertyArgs = {
    input: EditPropertyInput;
    analytics?: Maybe<EditPropertyAnalytics>;
};
export declare type MutationEditPropertiesArgs = {
    input: Array<EditPropertyInput>;
    analytics?: Maybe<EditPropertyAnalytics>;
};
export declare type MutationRemovePropertiesArgs = {
    input: Array<RemovePropertyInput>;
};
export declare type MutationRemovePropertiesNewArgs = {
    input: Array<RemovePropertyInput>;
};
export declare type MutationDeletePropertiesArgs = {
    input: DeleteRestorePropertyInput;
};
export declare type MutationRestorePropertiesArgs = {
    input: DeleteRestorePropertyInput;
};
export declare type MutationDeleteEventPropertiesArgs = {
    input: DeleteRestoreEventPropertiesInput;
};
export declare type MutationRestoreEventPropertiesArgs = {
    input: DeleteRestoreEventPropertiesInput;
};
export declare type MutationCreateSourceArgs = {
    input: CreateSourceInput;
};
export declare type MutationEditSourceArgs = {
    input: EditSourceInput;
};
export declare type MutationDeleteSourceArgs = {
    input: DeleteSourceInput;
};
export declare type MutationCreateDestinationArgs = {
    input: CreateDestinationInput;
};
export declare type MutationEditDestinationArgs = {
    input: EditDestinationInput;
};
export declare type MutationDeleteDestinationArgs = {
    input: DeleteDestinationInput;
};
export declare type MutationEditSettingsArgs = {
    input: EditSettingsInput;
};
export declare type MutationBulkEditSettingsArgs = {
    input: BulkEditSettingsInput;
};
export declare type MutationCreateApiTokenArgs = {
    input: CreateApiTokenInput;
};
export declare type MutationDeleteApiTokenArgs = {
    input: DeleteApiTokenInput;
};
export declare type MutationPublishVersionArgs = {
    input: PublishVersionInput;
};
export declare type MutationResetVersionArgs = {
    input: ResetVersionInput;
};
export declare type MutationCreateBranchArgs = {
    input: CreateBranchInput;
};
export declare type MutationEditBranchArgs = {
    input: EditBranchInput;
};
export declare type MutationDeleteBranchArgs = {
    input: DeleteBranchInput;
};
export declare type MutationForkBranchArgs = {
    input: ForkBranchInput;
};
export declare type MutationCreatePullRequestArgs = {
    input: CreatePullRequestInput;
};
export declare type MutationEditPullRequestArgs = {
    input: EditPullRequestInput;
};
export declare type MutationDeletePullRequestArgs = {
    input: DeletePullRequestInput;
};
export declare type MutationMergePullRequestArgs = {
    input: MergePullRequestInput;
};
export declare type MutationRefreshPullRequestArgs = {
    input: RefreshPullRequestInput;
};
export declare type MutationCreatePullRequestReviewArgs = {
    input: CreatePullRequestReviewInput;
};
export declare type MutationCreateSlackIntegrationArgs = {
    input: CreateSlackIntegrationInput;
};
export declare type MutationEditSlackIntegrationArgs = {
    input: EditSlackIntegrationInput;
};
export declare type MutationDeleteSlackIntegrationArgs = {
    input: DeleteSlackIntegrationInput;
};
export declare type MutationCreateHermesSlackIntegrationArgs = {
    input: CreateHermesSlackIntegrationInput;
};
export declare type MutationEditHermesSlackIntegrationArgs = {
    input: EditHermesSlackIntegrationInput;
};
export declare type MutationDeleteHermesSlackIntegrationArgs = {
    input: DeleteHermesSlackIntegrationInput;
};
export declare type MutationDeleteJiraIntegrationArgs = {
    input: DeleteJiraIntegrationInput;
};
export declare type MutationCreateJiraTicketArgs = {
    input: CreateJiraTicketInput;
};
export declare type MutationLinkJiraTicketArgs = {
    input: LinkJiraTicketInput;
};
export declare type MutationCreateJiraCommentArgs = {
    input: CreateJiraCommentInput;
};
export declare type MutationDeleteJiraTicketArgs = {
    input: DeleteJiraTicketInput;
};
export declare type MutationCreateCommentArgs = {
    input: CreateCommentInput;
};
export declare type MutationEditCommentArgs = {
    input: EditCommentInput;
};
export declare type MutationDeleteCommentsArgs = {
    input: DeleteCommentInput;
};
export declare type MutationCreateScheduledActionsArgs = {
    input: Array<CreateScheduledActionInput>;
};
export declare type MutationDeleteScheduledActionsArgs = {
    input: Array<DeleteScheduledActionInput>;
};
export declare type MutationEditScheduledActionsArgs = {
    input: Array<EditScheduledActionInput>;
};
export declare type MutationCreateScheduledActionVotesArgs = {
    input: Array<CreateScheduledActionVoteInput>;
};
export declare type MutationCreateScheduledActionVotesForAppArgs = {
    input: Array<CreateScheduledActionVoteForAppInput>;
};
export declare type MutationDeleteScheduledActionVotesArgs = {
    input: Array<DeleteScheduledActionVoteInput>;
};
export declare type MutationDeleteScheduledActionVotesForAppArgs = {
    input: Array<DeleteScheduledActionVoteForAppInput>;
};
export declare type MutationApplySuggestionsArgs = {
    appId: Scalars['String'];
    branchName: Scalars['String'];
    input: Array<ApplySuggestionInput>;
};
export declare type MutationRejectSuggestionsArgs = {
    appId: Scalars['String'];
    input: Array<RejectSuggestionInput>;
};
export declare type MutationUpsertRemoteConfigsArgs = {
    orgId: Scalars['Int'];
    appId: Scalars['Int'];
    config: Scalars['JSON'];
};
export declare type ObservableEvent = {
    __typename?: 'ObservableEvent';
    id: Scalars['ID'];
    versionId: Scalars['ID'];
    queryId?: Maybe<Scalars['ID']>;
    name: Scalars['String'];
    dateCreated: Scalars['DateTime'];
    dateModified: Scalars['DateTime'];
    modifiedBy: Scalars['String'];
    modifiedByUser?: Maybe<User>;
    description: Scalars['String'];
    displayName: Scalars['String'];
    category: Scalars['String'];
    isActiveAction: