@aws-amplify/appsync-modelgen-plugin/lib/visitors/appsync-visitor.d.ts

import { BaseVisitor, NormalizedScalarsMap, ParsedConfig, RawConfig } from '@graphql-codegen/visitor-plugin-common';
import { EnumTypeDefinitionNode, FieldDefinitionNode, GraphQLNamedType, GraphQLSchema, ObjectTypeDefinitionNode, InputValueDefinitionNode, InputObjectTypeDefinitionNode, UnionTypeDefinitionNode, InterfaceTypeDefinitionNode } from 'graphql';
import { CodeGenFieldConnection } from '../utils/process-connections';
export declare enum CodeGenGenerateEnum {
    metadata = "metadata",
    code = "code",
    loader = "loader"
}
export interface RawAppSyncModelConfig extends RawConfig {
    target: string;
    selectedType?: string;
    generate?: CodeGenGenerateEnum;
    directives?: string;
    isDataStoreEnabled?: boolean;
    isTimestampFieldsAdded?: boolean;
    handleListNullabilityTransparently?: boolean;
    usePipelinedTransformer?: boolean;
    transformerVersion?: number;
    respectPrimaryKeyAttributesOnConnectionField?: boolean;
    improvePluralization?: boolean;
    generateModelsForLazyLoadAndCustomSelectionSet?: boolean;
    codegenVersion: string;
}
export interface ParsedAppSyncModelConfig extends ParsedConfig {
    selectedType?: string;
    generate?: CodeGenGenerateEnum;
    target?: string;
    isDataStoreEnabled?: boolean;
    isTimestampFieldsAdded?: boolean;
    handleListNullabilityTransparently?: boolean;
    usePipelinedTransformer?: boolean;
    transformerVersion?: number;
    respectPrimaryKeyAttributesOnConnectionField?: boolean;
    improvePluralization?: boolean;
    generateModelsForLazyLoadAndCustomSelectionSet?: boolean;
    codegenVersion?: string;
}
export declare type CodeGenArgumentsMap = Record<string, any>;
export declare type CodeGenDirective = {
    name: string;
    arguments: CodeGenArgumentsMap;
};
export declare type CodeGenFieldDirective = CodeGenDirective & {
    fieldName: string;
};
export declare type CodeGenInputValue = TypeInfo & {
    name: string;
    directives: CodeGenDirectives;
};
export declare type CodeGenDirectives = CodeGenDirective[];
export declare type CodeGenInputValues = CodeGenInputValue[];
export declare type CodeGenField = TypeInfo & {
    name: string;
    directives: CodeGenDirectives;
    parameters?: CodeGenInputValues;
    connectionInfo?: CodeGenFieldConnection;
    isReadOnly?: boolean;
    primaryKeyInfo?: CodeGenPrimaryKeyFieldInfo;
};
export declare type CodeGenPrimaryKeyFieldInfo = {
    primaryKeyType: CodeGenPrimaryKeyType;
    sortKeyFields: CodeGenField[];
};
export declare enum CodeGenPrimaryKeyType {
    ManagedId = "ManagedId",
    OptionallyManagedId = "OptionallyManagedId",
    CustomId = "CustomId"
}
export declare type TypeInfo = {
    type: string;
    isList: boolean;
    isNullable: boolean;
    isListNullable?: boolean;
    baseType?: GraphQLNamedType | null;
};
export declare type CodeGenModel = {
    name: string;
    type: 'model';
    directives: CodeGenDirectives;
    fields: CodeGenField[];
};
export declare type CodeGenEnum = {
    name: string;
    type: 'enum';
    values: CodeGenEnumValueMap;
};
export declare type CodeGenModelMap = {
    [modelName: string]: CodeGenModel;
};
export declare type CodeGenEnumValueMap = {
    [enumConvertedName: string]: string;
};
export declare type CodeGenEnumMap = Record<string, CodeGenEnum>;
export declare type CodeGenQuery = CodeGenField & {
    operationType: 'query';
};
export declare type CodeGenQueryMap = Record<string, CodeGenQuery>;
export declare type CodeGenMutation = CodeGenField & {
    operationType: 'mutation';
};
export declare type CodeGenMutationMap = Record<string, CodeGenMutation>;
export declare type CodeGenSubscription = CodeGenField & {
    operationType: 'subscription';
};
export declare type CodeGenInputObject = {
    name: string;
    type: 'input';
    inputValues: CodeGenInputValues;
};
export declare type CodeGenSubscriptionMap = Record<string, CodeGenSubscription>;
export declare type CodeGenInputObjectMap = Record<string, CodeGenInputObject>;
export declare type CodeGenUnion = {
    name: string;
    type: 'union';
    typeNames: string[];
};
export declare type CodeGenUnionMap = Record<string, CodeGenUnion>;
export declare type CodeGenInterface = {
    name: string;
    type: 'interface';
    fields: CodeGenField[];
};
export declare type CodeGenInterfaceMap = Record<string, CodeGenInterface>;
declare type ManyToManyContext = {
    model: CodeGenModel;
    field: CodeGenField;
    directive: CodeGenDirective;
};
export declare class AppSyncModelVisitor<TRawConfig extends RawAppSyncModelConfig = RawAppSyncModelConfig, TPluginConfig extends ParsedAppSyncModelConfig = ParsedAppSyncModelConfig> extends BaseVisitor<TRawConfig, TPluginConfig> {
    protected _schema: GraphQLSchema;
    protected READ_ONLY_FIELDS: string[];
    protected SCALAR_TYPE_MAP: Record<string, string>;
    protected modelMap: CodeGenModelMap;
    protected nonModelMap: CodeGenModelMap;
    protected enumMap: CodeGenEnumMap;
    protected queryMap: CodeGenQueryMap;
    protected mutationMap: CodeGenMutationMap;
    protected subscriptionMap: CodeGenSubscriptionMap;
    protected inputObjectMap: CodeGenInputObjectMap;
    protected unionMap: CodeGenUnionMap;
    protected interfaceMap: CodeGenInterfaceMap;
    protected typesToSkip: string[];
    constructor(_schema: GraphQLSchema, rawConfig: TRawConfig, additionalConfig: Partial<TPluginConfig>, defaultScalars?: NormalizedScalarsMap);
    ObjectTypeDefinition(node: ObjectTypeDefinitionNode, index?: string | number, parent?: any): void;
    FieldDefinition(node: FieldDefinitionNode): CodeGenField;
    InputObjectTypeDefinition(node: InputObjectTypeDefinitionNode): void;
    InputValueDefinition(node: InputValueDefinitionNode): CodeGenInputValue;
    EnumTypeDefinition(node: EnumTypeDefinitionNode): void;
    UnionTypeDefinition(node: UnionTypeDefinitionNode): void;
    InterfaceTypeDefinition(node: InterfaceTypeDefinitionNode): void;
    processDirectives(shouldUseModelNameFieldInHasManyAndBelongsTo: boolean, shouldImputeKeyForUniDirectionalHasMany: boolean, shouldUseFieldsInAssociatedWithInHasOne?: boolean): void;
    generate(): string;
    private getDirectives;
    private getDirectiveArguments;
    protected getSelectedModels(): CodeGenModelMap;
    protected getSelectedNonModels(): CodeGenModelMap;
    protected getSelectedEnums(): CodeGenEnumMap;
    protected selectedTypeIsEnum(): boolean;
    protected selectedTypeIsNonModel(): boolean;
    protected getNativeType(field: CodeGenField, options?: {}): string;
    protected getListType(typeStr: string, field: CodeGenField): string;
    protected getFieldName(field: CodeGenField): string;
    protected getEnumName(enumField: CodeGenEnum | string): string;
    protected getModelName(model: CodeGenModel): string;
    protected getNonModelName(model: CodeGenModel): string;
    protected getEnumValue(value: string): string;
    protected getModelPrimaryKeyField(model: CodeGenModel): CodeGenField;
    protected isEnumType(field: CodeGenField): boolean;
    protected isModelType(field: CodeGenField): boolean;
    protected isNonModelType(field: CodeGenField): boolean;
    protected computeVersion(): string;
    protected sortFields(model: CodeGenModel): void;
    protected ensurePrimaryKeyField(model: CodeGenModel, directives: CodeGenDirective[]): void;
    protected ensurePrimaryKeyFieldV2(model: CodeGenModel, directives: CodeGenDirective[]): void;
    protected ensurePrimaryKeyFieldV1(model: CodeGenModel, directives: CodeGenDirective[]): void;
    protected getPrimaryKeyFieldByName(model: CodeGenModel, primaryKeyFieldName: string): CodeGenField;
    protected ensureIdField(model: CodeGenModel): void;
    protected processConnectionDirective(): void;
    protected generateIntermediateModel(firstModel: CodeGenModel, secondModel: CodeGenModel, relationName: string): CodeGenModel;
    protected generateIntermediateModelPrimaryKeyFieldName(model: CodeGenModel): string;
    protected generateIntermediateModelSortKeyFieldName(model: CodeGenModel, sortKeyField: CodeGenField): string;
    protected getSortKeyFields(model: CodeGenModel): CodeGenField[];
    protected determinePrimaryKeyFieldname(model: CodeGenModel): string;
    protected convertManyToManyDirectives(contexts: ManyToManyContext[]): void;
    protected processManyToManyDirectives(): void;
    protected processConnectionDirectivesV2(shouldUseModelNameFieldInHasManyAndBelongsTo: boolean, shouldImputeKeyForUniDirectionalHasMany: boolean, shouldUseFieldsInAssociatedWithInHasOne: boolean): void;
    protected processV2KeyDirectives(): void;
    protected processAuthDirectives(): void;
    protected pluralizeModelName(model: CodeGenModel): string;
    protected addTimestampFields(model: CodeGenModel, directive: CodeGenDirective): void;
    protected isRequiredField(field: CodeGenField): boolean | undefined;
    protected isCustomPKEnabled(): boolean;
    protected isGenerateModelsForLazyLoadAndCustomSelectionSet(): boolean;
    get models(): CodeGenModelMap;
    get enums(): CodeGenEnumMap;
    get nonModels(): CodeGenModelMap;
    get queries(): CodeGenQueryMap;
    get mutations(): CodeGenMutationMap;
    get subscriptions(): CodeGenSubscriptionMap;
    get inputs(): CodeGenInputObjectMap;
    get unions(): CodeGenUnionMap;
    get interfaces(): CodeGenInterfaceMap;
}
export {};
//# sourceMappingURL=appsync-visitor.d.ts.map