@graphql-inspector/cli 3.4.13-alpha-20230417141810-fd2d33e7 → 3.4.13

package/typings/core/src/diff/changes/change.d.ts

@@ -60,10 +60,508 @@ export declare enum CriticalityLevel {
 export interface Criticality {
     level: CriticalityLevel;
     reason?: string;
+    /** Is `true` if the criticality is safe, because of the usage determined via the `checkUsage` config option. */
+    isSafeBasedOnUsage?: boolean;
 }
-export interface Change {
+export interface Change<TChange extends keyof Changes = any> {
     message: string;
     path?: string;
-    type: ChangeType;
+    type: TChange;
+    meta: Changes[TChange]['meta'];
     criticality: Criticality;
 }
+export type FieldArgumentDescriptionChangedChange = {
+    type: ChangeType.FieldArgumentDescriptionChanged;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        argumentName: string;
+        oldDescription: string | null;
+        newDescription: string | null;
+    };
+};
+export type FieldArgumentDefaultChangedChange = {
+    type: ChangeType.FieldArgumentDefaultChanged;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        argumentName: string;
+        oldDefaultValue?: string;
+        newDefaultValue?: string;
+    };
+};
+export type FieldArgumentTypeChangedChange = {
+    type: ChangeType.FieldArgumentTypeChanged;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        argumentName: string;
+        oldArgumentType: string;
+        newArgumentType: string;
+        isSafeArgumentTypeChange: boolean;
+    };
+};
+export type DirectiveRemovedChange = {
+    type: ChangeType.DirectiveRemoved;
+    meta: {
+        removedDirectiveName: string;
+    };
+};
+export type DirectiveAddedChange = {
+    type: ChangeType.DirectiveAdded;
+    meta: {
+        addedDirectiveName: string;
+    };
+};
+export type DirectiveDescriptionChangedChange = {
+    type: ChangeType.DirectiveDescriptionChanged;
+    meta: {
+        directiveName: string;
+        oldDirectiveDescription: string | null;
+        newDirectiveDescription: string | null;
+    };
+};
+export type DirectiveLocationAddedChange = {
+    type: ChangeType.DirectiveLocationAdded;
+    meta: {
+        directiveName: string;
+        addedDirectiveLocation: string;
+    };
+};
+export type DirectiveLocationRemovedChange = {
+    type: ChangeType.DirectiveLocationRemoved;
+    meta: {
+        directiveName: string;
+        removedDirectiveLocation: string;
+    };
+};
+export type DirectiveArgumentAddedChange = {
+    type: ChangeType.DirectiveArgumentAdded;
+    meta: {
+        directiveName: string;
+        addedDirectiveArgumentName: string;
+        addedDirectiveArgumentTypeIsNonNull: boolean;
+    };
+};
+export type DirectiveArgumentRemovedChange = {
+    type: ChangeType.DirectiveArgumentRemoved;
+    meta: {
+        directiveName: string;
+        removedDirectiveArgumentName: string;
+    };
+};
+export type DirectiveArgumentDescriptionChangedChange = {
+    type: ChangeType.DirectiveArgumentDescriptionChanged;
+    meta: {
+        directiveName: string;
+        directiveArgumentName: string;
+        oldDirectiveArgumentDescription: string | null;
+        newDirectiveArgumentDescription: string | null;
+    };
+};
+export type DirectiveArgumentDefaultValueChangedChange = {
+    type: ChangeType.DirectiveArgumentDefaultValueChanged;
+    meta: {
+        directiveName: string;
+        directiveArgumentName: string;
+        oldDirectiveArgumentDefaultValue?: string;
+        newDirectiveArgumentDefaultValue?: string;
+    };
+};
+export type DirectiveArgumentTypeChangedChange = {
+    type: ChangeType.DirectiveArgumentTypeChanged;
+    meta: {
+        directiveName: string;
+        directiveArgumentName: string;
+        oldDirectiveArgumentType: string;
+        newDirectiveArgumentType: string;
+        /** Note: this could also be computed from oldDirectiveArgumentType and newDirectiveArgumentType */
+        isSafeDirectiveArgumentTypeChange: boolean;
+    };
+};
+export type EnumValueRemovedChange = {
+    type: ChangeType.EnumValueRemoved;
+    meta: {
+        enumName: string;
+        removedEnumValueName: string;
+        isEnumValueDeprecated: boolean;
+    };
+};
+export type EnumValueAddedChange = {
+    type: ChangeType.EnumValueAdded;
+    meta: {
+        enumName: string;
+        addedEnumValueName: string;
+    };
+};
+export type EnumValueDescriptionChangedChange = {
+    type: ChangeType.EnumValueDescriptionChanged;
+    meta: {
+        enumName: string;
+        enumValueName: string;
+        oldEnumValueDescription: string | null;
+        newEnumValueDescription: string | null;
+    };
+};
+export type EnumValueDeprecationReasonChangedChange = {
+    type: ChangeType.EnumValueDeprecationReasonChanged;
+    meta: {
+        enumName: string;
+        enumValueName: string;
+        oldEnumValueDeprecationReason: string;
+        newEnumValueDeprecationReason: string;
+    };
+};
+export type EnumValueDeprecationReasonAddedChange = {
+    type: ChangeType.EnumValueDeprecationReasonAdded;
+    meta: {
+        enumName: string;
+        enumValueName: string;
+        addedValueDeprecationReason: string;
+    };
+};
+export type EnumValueDeprecationReasonRemovedChange = {
+    type: ChangeType.EnumValueDeprecationReasonRemoved;
+    meta: {
+        enumName: string;
+        enumValueName: string;
+        removedEnumValueDeprecationReason: string;
+    };
+};
+export type FieldRemovedChange = {
+    type: ChangeType.FieldRemoved;
+    meta: {
+        typeName: string;
+        removedFieldName: string;
+        isRemovedFieldDeprecated: boolean;
+        typeType: string;
+    };
+};
+export type FieldAddedChange = {
+    type: ChangeType.FieldAdded;
+    meta: {
+        typeName: string;
+        addedFieldName: string;
+        typeType: string;
+    };
+};
+export type FieldDescriptionChangedChange = {
+    type: ChangeType.FieldDescriptionChanged;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        oldDescription: string;
+        newDescription: string;
+    };
+};
+export type FieldDescriptionAddedChange = {
+    type: ChangeType.FieldDescriptionAdded;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        addedDescription: string;
+    };
+};
+export type FieldDescriptionRemovedChange = {
+    type: ChangeType.FieldDescriptionRemoved;
+    meta: {
+        typeName: string;
+        fieldName: string;
+    };
+};
+export type FieldDeprecationAddedChange = {
+    type: ChangeType.FieldDeprecationAdded;
+    meta: {
+        typeName: string;
+        fieldName: string;
+    };
+};
+export type FieldDeprecationRemovedChange = {
+    type: ChangeType.FieldDeprecationRemoved;
+    meta: {
+        typeName: string;
+        fieldName: string;
+    };
+};
+export type FieldDeprecationReasonChangedChange = {
+    type: ChangeType.FieldDeprecationReasonChanged;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        oldDeprecationReason: string;
+        newDeprecationReason: string;
+    };
+};
+export type FieldDeprecationReasonAddedChange = {
+    type: ChangeType.FieldDeprecationReasonAdded;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        addedDeprecationReason: string;
+    };
+};
+export type FieldDeprecationReasonRemovedChange = {
+    type: ChangeType.FieldDeprecationReasonRemoved;
+    meta: {
+        typeName: string;
+        fieldName: string;
+    };
+};
+export type FieldTypeChangedChange = {
+    type: ChangeType.FieldTypeChanged;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        oldFieldType: string;
+        newFieldType: string;
+        isSafeFieldTypeChange: boolean;
+    };
+};
+export type FieldArgumentAddedChange = {
+    type: ChangeType.FieldArgumentAdded;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        addedArgumentName: string;
+        addedArgumentType: string;
+        hasDefaultValue: boolean;
+        isAddedFieldArgumentBreaking: boolean;
+    };
+};
+export type FieldArgumentRemovedChange = {
+    type: ChangeType.FieldArgumentRemoved;
+    meta: {
+        typeName: string;
+        fieldName: string;
+        removedFieldArgumentName: string;
+        removedFieldType: string;
+    };
+};
+export type InputFieldRemovedChange = {
+    type: ChangeType.InputFieldRemoved;
+    meta: {
+        inputName: string;
+        removedFieldName: string;
+        isInputFieldDeprecated: boolean;
+    };
+};
+export type InputFieldAddedChange = {
+    type: ChangeType.InputFieldAdded;
+    meta: {
+        inputName: string;
+        addedInputFieldName: string;
+        isAddedInputFieldTypeNullable: boolean;
+        addedInputFieldType: string;
+    };
+};
+export type InputFieldDescriptionAddedChange = {
+    type: ChangeType.InputFieldDescriptionAdded;
+    meta: {
+        inputName: string;
+        inputFieldName: string;
+        addedInputFieldDescription: string;
+    };
+};
+export type InputFieldDescriptionRemovedChange = {
+    type: ChangeType.InputFieldDescriptionRemoved;
+    meta: {
+        inputName: string;
+        inputFieldName: string;
+        removedDescription: string;
+    };
+};
+export type InputFieldDescriptionChangedChange = {
+    type: ChangeType.InputFieldDescriptionChanged;
+    meta: {
+        inputName: string;
+        inputFieldName: string;
+        oldInputFieldDescription: string;
+        newInputFieldDescription: string;
+    };
+};
+export type InputFieldDefaultValueChangedChange = {
+    type: ChangeType.InputFieldDefaultValueChanged;
+    meta: {
+        inputName: string;
+        inputFieldName: string;
+        oldDefaultValue?: string;
+        newDefaultValue?: string;
+    };
+};
+export type InputFieldTypeChangedChange = {
+    type: ChangeType.InputFieldTypeChanged;
+    meta: {
+        inputName: string;
+        inputFieldName: string;
+        oldInputFieldType: string;
+        newInputFieldType: string;
+        isInputFieldTypeChangeSafe: boolean;
+    };
+};
+export type ObjectTypeInterfaceAddedChange = {
+    type: ChangeType.ObjectTypeInterfaceAdded;
+    meta: {
+        objectTypeName: string;
+        addedInterfaceName: string;
+    };
+};
+export type ObjectTypeInterfaceRemovedChange = {
+    type: ChangeType.ObjectTypeInterfaceRemoved;
+    meta: {
+        objectTypeName: string;
+        removedInterfaceName: string;
+    };
+};
+export type SchemaQueryTypeChangedChange = {
+    type: ChangeType.SchemaQueryTypeChanged;
+    meta: {
+        oldQueryTypeName: string;
+        newQueryTypeName: string;
+    };
+};
+export type SchemaMutationTypeChangedChange = {
+    type: ChangeType.SchemaMutationTypeChanged;
+    meta: {
+        oldMutationTypeName: string;
+        newMutationTypeName: string;
+    };
+};
+export type SchemaSubscriptionTypeChangedChange = {
+    type: ChangeType.SchemaSubscriptionTypeChanged;
+    meta: {
+        oldSubscriptionTypeName: string;
+        newSubscriptionTypeName: string;
+    };
+};
+export type TypeRemovedChange = {
+    type: ChangeType.TypeRemoved;
+    meta: {
+        removedTypeName: string;
+    };
+};
+export type TypeAddedChange = {
+    type: ChangeType.TypeAdded;
+    meta: {
+        addedTypeName: string;
+    };
+};
+export type TypeKindChangedChange = {
+    type: ChangeType.TypeKindChanged;
+    meta: {
+        typeName: string;
+        oldTypeKind: string;
+        newTypeKind: string;
+    };
+};
+export type TypeDescriptionChangedChange = {
+    type: ChangeType.TypeDescriptionChanged;
+    meta: {
+        typeName: string;
+        oldTypeDescription: string;
+        newTypeDescription: string;
+    };
+};
+export type TypeDescriptionAddedChange = {
+    type: ChangeType.TypeDescriptionAdded;
+    meta: {
+        typeName: string;
+        addedTypeDescription: string;
+    };
+};
+export type TypeDescriptionRemovedChange = {
+    type: ChangeType.TypeDescriptionRemoved;
+    meta: {
+        typeName: string;
+        removedTypeDescription: string;
+    };
+};
+export type UnionMemberRemovedChange = {
+    type: ChangeType.UnionMemberRemoved;
+    meta: {
+        unionName: string;
+        removedUnionMemberTypeName: string;
+    };
+};
+export type UnionMemberAddedChange = {
+    type: ChangeType.UnionMemberAdded;
+    meta: {
+        unionName: string;
+        addedUnionMemberTypeName: string;
+    };
+};
+type Changes = {
+    [ChangeType.TypeAdded]: TypeAddedChange;
+    [ChangeType.TypeRemoved]: TypeRemovedChange;
+    [ChangeType.TypeKindChanged]: TypeKindChangedChange;
+    [ChangeType.TypeDescriptionChanged]: TypeDescriptionChangedChange;
+    [ChangeType.TypeDescriptionAdded]: TypeDescriptionAddedChange;
+    [ChangeType.TypeDescriptionRemoved]: TypeDescriptionRemovedChange;
+    [ChangeType.UnionMemberRemoved]: UnionMemberRemovedChange;
+    [ChangeType.UnionMemberAdded]: UnionMemberAddedChange;
+    [ChangeType.SchemaQueryTypeChanged]: SchemaQueryTypeChangedChange;
+    [ChangeType.SchemaMutationTypeChanged]: SchemaMutationTypeChangedChange;
+    [ChangeType.SchemaSubscriptionTypeChanged]: SchemaSubscriptionTypeChangedChange;
+    [ChangeType.ObjectTypeInterfaceAdded]: ObjectTypeInterfaceAddedChange;
+    [ChangeType.ObjectTypeInterfaceRemoved]: ObjectTypeInterfaceRemovedChange;
+    [ChangeType.InputFieldRemoved]: InputFieldRemovedChange;
+    [ChangeType.InputFieldAdded]: InputFieldAddedChange;
+    [ChangeType.InputFieldDescriptionAdded]: InputFieldDescriptionAddedChange;
+    [ChangeType.InputFieldDescriptionRemoved]: InputFieldDescriptionRemovedChange;
+    [ChangeType.InputFieldDescriptionChanged]: InputFieldDescriptionChangedChange;
+    [ChangeType.InputFieldDefaultValueChanged]: InputFieldDefaultValueChangedChange;
+    [ChangeType.InputFieldTypeChanged]: InputFieldTypeChangedChange;
+    [ChangeType.FieldRemoved]: FieldRemovedChange;
+    [ChangeType.FieldAdded]: FieldAddedChange;
+    [ChangeType.FieldDescriptionAdded]: FieldDescriptionAddedChange;
+    [ChangeType.FieldDescriptionRemoved]: FieldDescriptionRemovedChange;
+    [ChangeType.FieldDescriptionChanged]: FieldDescriptionChangedChange;
+    [ChangeType.FieldArgumentAdded]: FieldArgumentAddedChange;
+    [ChangeType.FieldArgumentRemoved]: FieldArgumentRemovedChange;
+    [ChangeType.InputFieldRemoved]: InputFieldRemovedChange;
+    [ChangeType.InputFieldAdded]: InputFieldAddedChange;
+    [ChangeType.InputFieldDescriptionAdded]: InputFieldDescriptionAddedChange;
+    [ChangeType.InputFieldDescriptionRemoved]: InputFieldDescriptionRemovedChange;
+    [ChangeType.InputFieldDescriptionChanged]: InputFieldDescriptionChangedChange;
+    [ChangeType.InputFieldDefaultValueChanged]: InputFieldDefaultValueChangedChange;
+    [ChangeType.InputFieldTypeChanged]: InputFieldTypeChangedChange;
+    [ChangeType.ObjectTypeInterfaceAdded]: ObjectTypeInterfaceAddedChange;
+    [ChangeType.ObjectTypeInterfaceRemoved]: ObjectTypeInterfaceRemovedChange;
+    [ChangeType.SchemaQueryTypeChanged]: SchemaQueryTypeChangedChange;
+    [ChangeType.SchemaMutationTypeChanged]: SchemaMutationTypeChangedChange;
+    [ChangeType.SchemaSubscriptionTypeChanged]: SchemaSubscriptionTypeChangedChange;
+    [ChangeType.TypeAdded]: TypeAddedChange;
+    [ChangeType.TypeRemoved]: TypeRemovedChange;
+    [ChangeType.TypeKindChanged]: TypeKindChangedChange;
+    [ChangeType.TypeDescriptionChanged]: TypeDescriptionChangedChange;
+    [ChangeType.TypeDescriptionRemoved]: TypeDescriptionRemovedChange;
+    [ChangeType.TypeDescriptionAdded]: TypeDescriptionAddedChange;
+    [ChangeType.UnionMemberAdded]: UnionMemberAddedChange;
+    [ChangeType.UnionMemberRemoved]: UnionMemberRemovedChange;
+    [ChangeType.DirectiveRemoved]: DirectiveRemovedChange;
+    [ChangeType.DirectiveAdded]: DirectiveAddedChange;
+    [ChangeType.DirectiveArgumentAdded]: DirectiveArgumentAddedChange;
+    [ChangeType.DirectiveArgumentRemoved]: DirectiveArgumentRemovedChange;
+    [ChangeType.DirectiveArgumentDescriptionChanged]: DirectiveArgumentDescriptionChangedChange;
+    [ChangeType.DirectiveArgumentDefaultValueChanged]: DirectiveArgumentDefaultValueChangedChange;
+    [ChangeType.DirectiveArgumentTypeChanged]: DirectiveArgumentTypeChangedChange;
+    [ChangeType.DirectiveDescriptionChanged]: DirectiveDescriptionChangedChange;
+    [ChangeType.FieldArgumentDescriptionChanged]: FieldArgumentDescriptionChangedChange;
+    [ChangeType.FieldArgumentDefaultChanged]: FieldArgumentDefaultChangedChange;
+    [ChangeType.FieldArgumentTypeChanged]: FieldArgumentTypeChangedChange;
+    [ChangeType.DirectiveLocationAdded]: DirectiveLocationAddedChange;
+    [ChangeType.DirectiveLocationRemoved]: DirectiveLocationRemovedChange;
+    [ChangeType.EnumValueRemoved]: EnumValueRemovedChange;
+    [ChangeType.EnumValueDescriptionChanged]: EnumValueDescriptionChangedChange;
+    [ChangeType.EnumValueDeprecationReasonChanged]: EnumValueDeprecationReasonChangedChange;
+    [ChangeType.EnumValueDeprecationReasonAdded]: EnumValueDeprecationReasonAddedChange;
+    [ChangeType.EnumValueDeprecationReasonRemoved]: EnumValueDeprecationReasonRemovedChange;
+    [ChangeType.EnumValueAdded]: EnumValueAddedChange;
+    [ChangeType.FieldDeprecationAdded]: FieldDeprecationAddedChange;
+    [ChangeType.FieldDeprecationRemoved]: FieldDeprecationRemovedChange;
+    [ChangeType.FieldDeprecationReasonChanged]: FieldDeprecationReasonChangedChange;
+    [ChangeType.FieldDeprecationReasonAdded]: FieldDeprecationReasonAddedChange;
+    [ChangeType.FieldDeprecationReasonRemoved]: FieldDeprecationReasonRemovedChange;
+    [ChangeType.FieldTypeChanged]: FieldTypeChangedChange;
+};
+export type SerializableChange = Changes[keyof Changes];
+export {};

package/typings/core/src/diff/changes/directive.d.cts

@@ -1,12 +1,148 @@
 import { DirectiveLocationEnum, GraphQLArgument, GraphQLDirective } from 'graphql';
-import { Change } from './change.cjs';
-export declare function directiveRemoved(directive: GraphQLDirective): Change;
-export declare function directiveAdded(directive: GraphQLDirective): Change;
-export declare function directiveDescriptionChanged(oldDirective: GraphQLDirective, newDirective: GraphQLDirective): Change;
-export declare function directiveLocationAdded(directive: GraphQLDirective, location: DirectiveLocationEnum): Change;
-export declare function directiveLocationRemoved(directive: GraphQLDirective, location: DirectiveLocationEnum): Change;
-export declare function directiveArgumentAdded(directive: GraphQLDirective, arg: GraphQLArgument): Change;
-export declare function directiveArgumentRemoved(directive: GraphQLDirective, arg: GraphQLArgument): Change;
-export declare function directiveArgumentDescriptionChanged(directive: GraphQLDirective, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;
-export declare function directiveArgumentDefaultValueChanged(directive: GraphQLDirective, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;
-export declare function directiveArgumentTypeChanged(directive: GraphQLDirective, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;
+import { Change, ChangeType, CriticalityLevel, DirectiveAddedChange, DirectiveArgumentAddedChange, DirectiveArgumentDefaultValueChangedChange, DirectiveArgumentDescriptionChangedChange, DirectiveArgumentRemovedChange, DirectiveArgumentTypeChangedChange, DirectiveDescriptionChangedChange, DirectiveLocationAddedChange, DirectiveLocationRemovedChange, DirectiveRemovedChange } from './change.cjs';
+export declare function directiveRemovedFromMeta(args: DirectiveRemovedChange): {
+    readonly criticality: {
+        readonly level: CriticalityLevel.Breaking;
+        readonly reason: "A directive could be in use of a client application. Removing it could break the client application.";
+    };
+    readonly type: ChangeType.DirectiveRemoved;
+    readonly message: string;
+    readonly path: `@${string}`;
+    readonly meta: {
+        removedDirectiveName: string;
+    };
+};
+export declare function directiveRemoved(directive: GraphQLDirective): Change<ChangeType.DirectiveRemoved>;
+export declare function directiveAddedFromMeta(args: DirectiveAddedChange): {
+    readonly criticality: {
+        readonly level: CriticalityLevel.NonBreaking;
+    };
+    readonly type: ChangeType.DirectiveAdded;
+    readonly message: string;
+    readonly path: `@${string}`;
+    readonly meta: {
+        addedDirectiveName: string;
+    };
+};
+export declare function directiveAdded(directive: GraphQLDirective): Change<ChangeType.DirectiveAdded>;
+export declare function directiveDescriptionChangedFromMeta(args: DirectiveDescriptionChangedChange): {
+    readonly criticality: {
+        readonly level: CriticalityLevel.NonBreaking;
+    };
+    readonly type: ChangeType.DirectiveDescriptionChanged;
+    readonly message: string;
+    readonly path: `@${string}`;
+    readonly meta: {
+        directiveName: string;
+        oldDirectiveDescription: string | null;
+        newDirectiveDescription: string | null;
+    };
+};
+export declare function directiveDescriptionChanged(oldDirective: GraphQLDirective, newDirective: GraphQLDirective): Change<ChangeType.DirectiveDescriptionChanged>;
+export declare function directiveLocationAddedFromMeta(args: DirectiveLocationAddedChange): {
+    readonly criticality: {
+        readonly level: CriticalityLevel.NonBreaking;
+    };
+    readonly type: ChangeType.DirectiveLocationAdded;
+    readonly message: string;
+    readonly path: `@${string}`;
+    readonly meta: {
+        directiveName: string;
+        addedDirectiveLocation: string;
+    };
+};
+export declare function directiveLocationAdded(directive: GraphQLDirective, location: DirectiveLocationEnum): Change<ChangeType.DirectiveLocationAdded>;
+export declare function directiveLocationRemovedFromMeta(args: DirectiveLocationRemovedChange): {
+    readonly criticality: {
+        readonly level: CriticalityLevel.Breaking;
+        readonly reason: "A directive could be in use of a client application. Removing it could break the client application.";
+    };
+    readonly type: ChangeType.DirectiveLocationRemoved;
+    readonly message: string;
+    readonly path: `@${string}`;
+    readonly meta: {
+        directiveName: string;
+        removedDirectiveLocation: string;
+    };
+};
+export declare function directiveLocationRemoved(directive: GraphQLDirective, location: DirectiveLocationEnum): Change<ChangeType.DirectiveLocationRemoved>;
+export declare function directiveArgumentAddedFromMeta(args: DirectiveArgumentAddedChange): {
+    readonly criticality: {
+        level: CriticalityLevel;
+        reason: string;
+    };
+    readonly type: ChangeType.DirectiveArgumentAdded;
+    readonly message: `Argument '${string}' was added to directive '${string}'`;
+    readonly path: `@${string}`;
+    readonly meta: {
+        directiveName: string;
+        addedDirectiveArgumentName: string;
+        addedDirectiveArgumentTypeIsNonNull: boolean;
+    };
+};
+export declare function directiveArgumentAdded(directive: GraphQLDirective, arg: GraphQLArgument): Change<ChangeType.DirectiveArgumentAdded>;
+export declare function directiveArgumentRemovedFromMeta(args: DirectiveArgumentRemovedChange): {
+    readonly criticality: {
+        readonly level: CriticalityLevel.Breaking;
+        readonly reason: "A directive argument could be in use of a client application. Removing the argument can break client applications.";
+    };
+    readonly type: ChangeType.DirectiveArgumentRemoved;
+    readonly message: string;
+    readonly path: `@${string}.${string}`;
+    readonly meta: {
+        directiveName: string;
+        removedDirectiveArgumentName: string;
+    };
+};
+export declare function directiveArgumentRemoved(directive: GraphQLDirective, arg: GraphQLArgument): Change<ChangeType.DirectiveArgumentRemoved>;
+export declare function directiveArgumentDescriptionChangedFromMeta(args: DirectiveArgumentDescriptionChangedChange): {
+    readonly criticality: {
+        readonly level: CriticalityLevel.NonBreaking;
+    };
+    readonly type: ChangeType.DirectiveArgumentDescriptionChanged;
+    readonly message: string;
+    readonly path: `@${string}.${string}`;
+    readonly meta: {
+        directiveName: string;
+        directiveArgumentName: string;
+        oldDirectiveArgumentDescription: string | null;
+        newDirectiveArgumentDescription: string | null;
+    };
+};
+export declare function directiveArgumentDescriptionChanged(directive: GraphQLDirective, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change<ChangeType.DirectiveArgumentDescriptionChanged>;
+export declare function directiveArgumentDefaultValueChangedFromMeta(args: DirectiveArgumentDefaultValueChangedChange): {
+    readonly criticality: {
+        readonly level: CriticalityLevel.Dangerous;
+        readonly reason: "Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.";
+    };
+    readonly type: ChangeType.DirectiveArgumentDefaultValueChanged;
+    readonly message: string;
+    readonly path: `@${string}.${string}`;
+    readonly meta: {
+        directiveName: string;
+        directiveArgumentName: string;
+        oldDirectiveArgumentDefaultValue?: string | undefined;
+        newDirectiveArgumentDefaultValue?: string | undefined;
+    };
+};
+export declare function directiveArgumentDefaultValueChanged(directive: GraphQLDirective, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change<ChangeType.DirectiveArgumentDefaultValueChanged>;
+export declare function directiveArgumentTypeChangedFromMeta(args: DirectiveArgumentTypeChangedChange): {
+    readonly criticality: {
+        level: CriticalityLevel;
+        reason: string;
+    } | {
+        level: CriticalityLevel;
+        reason?: undefined;
+    };
+    readonly type: ChangeType.DirectiveArgumentTypeChanged;
+    readonly message: string;
+    readonly path: `@${string}.${string}`;
+    readonly meta: {
+        directiveName: string;
+        directiveArgumentName: string;
+        oldDirectiveArgumentType: string;
+        newDirectiveArgumentType: string;
+        isSafeDirectiveArgumentTypeChange: boolean;
+    };
+};
+export declare function directiveArgumentTypeChanged(directive: GraphQLDirective, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change<ChangeType.DirectiveArgumentTypeChanged>;