## API Report File for "@aws-amplify/graphql-transformer-interfaces"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { BackedDataSource } from 'aws-cdk-lib/aws-appsync';
import { BaseDataSource } from 'aws-cdk-lib/aws-appsync';
import { CfnApiKey } from 'aws-cdk-lib/aws-appsync';
import { CfnDataSource } from 'aws-cdk-lib/aws-appsync';
import { CfnDomain } from 'aws-cdk-lib/aws-elasticsearch';
import { CfnEventSourceMapping } from 'aws-cdk-lib/aws-lambda';
import { CfnFunction } from 'aws-cdk-lib/aws-lambda';
import { CfnFunctionConfiguration } from 'aws-cdk-lib/aws-appsync';
import { CfnGraphQLApi } from 'aws-cdk-lib/aws-appsync';
import { CfnGraphQLSchema } from 'aws-cdk-lib/aws-appsync';
import { CfnParameter } from 'aws-cdk-lib';
import { CfnParameterProps } from 'aws-cdk-lib';
import { CfnPolicy } from 'aws-cdk-lib/aws-iam';
import { CfnResolver } from 'aws-cdk-lib/aws-appsync';
import { CfnResource } from 'aws-cdk-lib';
import { CfnRole } from 'aws-cdk-lib/aws-iam';
import { CfnStack } from 'aws-cdk-lib';
import { CfnTable } from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
import { DirectiveDefinitionNode } from 'graphql';
import { DirectiveNode } from 'graphql';
import { DocumentNode } from 'graphql';
import { Duration } from 'aws-cdk-lib';
import { DynamoDbDataSource } from 'aws-cdk-lib/aws-appsync';
import { EnumTypeDefinitionNode } from 'graphql';
import { EnumTypeExtensionNode } from 'graphql';
import { EnumValueDefinitionNode } from 'graphql';
import { FieldDefinitionNode } from 'graphql';
import { FieldNode } from 'graphql';
import { Grant } from 'aws-cdk-lib/aws-iam';
import { GraphqlApiBase } from 'aws-cdk-lib/aws-appsync';
import { HttpDataSource } from 'aws-cdk-lib/aws-appsync';
import { IAsset } from 'aws-cdk-lib';
import { IConstruct } from 'constructs';
import { IFunction } from 'aws-cdk-lib/aws-lambda';
import { IGrantable } from 'aws-cdk-lib/aws-iam';
import { ILayerVersion } from 'aws-cdk-lib/aws-lambda';
import { InputObjectTypeDefinitionNode } from 'graphql';
import { InputObjectTypeExtensionNode } from 'graphql';
import { InputValueDefinitionNode } from 'graphql';
import { InterfaceTypeDefinitionNode } from 'graphql';
import { InterfaceTypeExtensionNode } from 'graphql';
import { IRole } from 'aws-cdk-lib/aws-iam';
import { ITable } from 'aws-cdk-lib/aws-dynamodb';
import { LambdaDataSource } from 'aws-cdk-lib/aws-appsync';
import { NoneDataSource } from 'aws-cdk-lib/aws-appsync';
import { ObjectTypeDefinitionNode } from 'graphql';
import { ObjectTypeExtensionNode } from 'graphql';
import { Runtime } from 'aws-cdk-lib/aws-lambda';
import { ScalarTypeDefinitionNode } from 'graphql';
import { SchemaDefinitionNode } from 'graphql';
import { Stack } from 'aws-cdk-lib';
import { TypeDefinitionNode } from 'graphql';
import { TypeSystemDefinitionNode } from 'graphql';
import { UnionTypeDefinitionNode } from 'graphql';
import { UnionTypeExtensionNode } from 'graphql';

// @public (undocumented)
export interface AmplifyApiGraphQlResourceStackTemplate {
    // Warning: (ae-forgotten-export) The symbol "AppsyncApiStack" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    api?: Partial<AppsyncApiStack>;
    // (undocumented)
    function?: Partial<FunctionDirectiveStack & AppsyncStackCommon>;
    // (undocumented)
    http?: Partial<HttpsDirectiveStack & AppsyncStackCommon>;
    // (undocumented)
    models?: Partial<Record<string, ModelDirectiveStack>>;
    // (undocumented)
    opensearch?: Partial<OpenSearchDirectiveStack & AppsyncStackCommon>;
    // Warning: (ae-forgotten-export) The symbol "PredictionsDirectiveStack" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    predictions?: Partial<PredictionsDirectiveStack & AppsyncStackCommon>;
}

// @public (undocumented)
export interface APIIAMResourceProvider {
    // (undocumented)
    resourceArns: (api: GraphQLAPIProvider) => string[];
}

// @public (undocumented)
export interface ApiKeyConfig {
    // (undocumented)
    apiKeyExpirationDate?: Date;
    // (undocumented)
    apiKeyExpirationDays: number;
    // (undocumented)
    description?: string;
}

// @public (undocumented)
export type AppSyncAuthConfiguration = {
    defaultAuthentication: AppSyncAuthConfigurationEntry;
    additionalAuthenticationProviders: Array<AppSyncAuthConfigurationEntry>;
};

// @public (undocumented)
export type AppSyncAuthConfigurationAPIKeyEntry = {
    authenticationType: 'API_KEY';
    apiKeyConfig?: ApiKeyConfig;
};

// Warning: (ae-forgotten-export) The symbol "AppSyncAuthConfigurationLambdaEntry" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type AppSyncAuthConfigurationEntry = AppSyncAuthConfigurationUserPoolEntry | AppSyncAuthConfigurationAPIKeyEntry | AppSyncAuthConfigurationIAMEntry | AppSyncAuthConfigurationOIDCEntry | AppSyncAuthConfigurationLambdaEntry;

// @public (undocumented)
export type AppSyncAuthConfigurationIAMEntry = {
    authenticationType: 'AWS_IAM';
};

// @public (undocumented)
export type AppSyncAuthConfigurationOIDCEntry = {
    authenticationType: 'OPENID_CONNECT';
    openIDConnectConfig?: OpenIDConnectConfig;
};

// @public (undocumented)
export type AppSyncAuthConfigurationUserPoolEntry = {
    authenticationType: 'AMAZON_COGNITO_USER_POOLS';
    userPoolConfig?: UserPoolConfig;
};

// @public (undocumented)
export type AppSyncAuthMode = 'API_KEY' | 'AMAZON_COGNITO_USER_POOLS' | 'AWS_IAM' | 'OPENID_CONNECT' | 'AWS_LAMBDA';

// @public (undocumented)
export enum AppSyncDataSourceType {
    // (undocumented)
    AMAZON_DYNAMODB = "AMAZON_DYNAMODB",
    // (undocumented)
    AMAZON_ELASTICSEARCH = "AMAZON_ELASTICSEARCH",
    // (undocumented)
    AWS_LAMBDA = "AWS_LAMBDA",
    // (undocumented)
    HTTP = "HTTP",
    // (undocumented)
    NONE = "NONE",
    // (undocumented)
    RELATIONAL_DATABASE = "RELATIONAL_DATABASE"
}

// @public (undocumented)
export interface AppSyncFunctionConfigurationProvider extends IConstruct {
    // (undocumented)
    readonly arn: string;
    // (undocumented)
    readonly functionId: string;
}

// @public (undocumented)
export type AppsyncStackCommon = {
    resolvers?: Record<string, CfnResolver>;
    appsyncFunctions?: Record<string, CfnFunctionConfiguration>;
};

// Warning: (ae-forgotten-export) The symbol "NoneDataSourceProvider" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type DataSourceInstance = ITable | CfnDomain | HttpDataSource | IFunction | NoneDataSourceProvider;

// @public (undocumented)
export interface DataSourceOptions {
    // (undocumented)
    readonly description?: string;
    // (undocumented)
    readonly name?: string;
}

// @public (undocumented)
export interface DataSourceProvider extends BackedDataSource {
}

// @public (undocumented)
export interface DeploymentResources extends ResolversFunctionsAndSchema, NestedStacks {
    // (undocumented)
    stackMapping: StackMapping;
}

// @public (undocumented)
export interface DynamoDbDataSourceOptions extends DataSourceOptions {
    // (undocumented)
    readonly serviceRole: IRole;
}

// @public (undocumented)
export type FieldMapEntry = {
    originalFieldName: string;
    currentFieldName: string;
};

// @public (undocumented)
export interface FunctionDirectiveStack {
    // (undocumented)
    lambdaDataSource: Record<string, CfnDataSource>;
    // (undocumented)
    lambdaDataSourceRole: Record<string, CfnRole>;
    // (undocumented)
    lambdaDataSourceServiceRoleDefaultPolicy: Record<string, CfnPolicy>;
}

// @public (undocumented)
export interface GraphQLAPIProvider extends IConstruct {
    // (undocumented)
    addSchemaDependency: (construct: CfnResource) => boolean;
    // (undocumented)
    addToSchema: (addition: string) => void;
    // (undocumented)
    readonly apiId: string;
    // (undocumented)
    grant: (grantee: IGrantable, resources: APIIAMResourceProvider, ...actions: string[]) => Grant;
    // (undocumented)
    grantMutation: (grantee: IGrantable, ...fields: string[]) => Grant;
    // (undocumented)
    grantQuery: (grantee: IGrantable, ...fields: string[]) => Grant;
    // (undocumented)
    grantSubscription: (grantee: IGrantable, ...fields: string[]) => Grant;
    // (undocumented)
    readonly host: TransformHostProvider;
    // (undocumented)
    readonly name: string;
}

// @public (undocumented)
export interface HttpsDirectiveStack {
    // (undocumented)
    httpDataSourceServiceRole?: Record<string, CfnRole>;
    // (undocumented)
    httpDataSourceServiceRoleDefaultPolicy?: Record<string, CfnPolicy>;
    // (undocumented)
    httpsDataSource?: Record<string, CfnDataSource>;
}

// @public (undocumented)
export interface InlineMappingTemplateProvider {
    // (undocumented)
    bind: (scope: Construct) => string;
    // (undocumented)
    getTemplateHash: () => string;
    // (undocumented)
    type: MappingTemplateType.INLINE;
}

// @public (undocumented)
export type MappingTemplateProvider = InlineMappingTemplateProvider | S3MappingTemplateProvider;

// @public (undocumented)
export enum MappingTemplateType {
    // (undocumented)
    INLINE = "INLINE",
    // (undocumented)
    S3_LOCATION = "S3_LOCATION"
}

// Warning: (ae-forgotten-export) The symbol "DDBModelDirectiveStack" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export type ModelDirectiveStack = AppsyncStackCommon & DDBModelDirectiveStack;

// @public (undocumented)
export type ModelFieldMap = {
    addMappedField: (entry: FieldMapEntry) => ModelFieldMap;
    addResolverReference: (entry: ResolverReferenceEntry) => ModelFieldMap;
    getMappedFields: () => ReadonlyArray_2<FieldMapEntry>;
    getResolverReferences: () => ReadonlyArray_2<ResolverReferenceEntry>;
};

// @public (undocumented)
export enum MutationFieldType {
    // (undocumented)
    CREATE = "CREATE",
    // (undocumented)
    DELETE = "DELETE",
    // (undocumented)
    UPDATE = "UPDATE"
}

// @public (undocumented)
export interface NestedStacks {
    // (undocumented)
    rootStack: Template;
    // (undocumented)
    stackMapping: Record<string, string>;
    // (undocumented)
    stacks: Record<string, Template>;
}

// @public (undocumented)
export interface OpenSearchDirectiveStack {
    // (undocumented)
    CloudwatchLogsAccess?: CfnPolicy;
    // (undocumented)
    OpenSearchAccessIAMRole?: CfnRole;
    // (undocumented)
    OpenSearchAccessIAMRoleDefaultPolicy?: CfnPolicy;
    // (undocumented)
    OpenSearchDataSource?: CfnDataSource;
    // (undocumented)
    OpenSearchDomain?: CfnDomain;
    // (undocumented)
    OpenSearchModelLambdaMapping?: Record<string, CfnEventSourceMapping>;
    // (undocumented)
    OpenSearchStreamingLambdaFunction?: CfnFunction;
    // (undocumented)
    OpenSearchStreamingLambdaIAMRole?: CfnRole;
    // (undocumented)
    OpenSearchStreamingLambdaIAMRoleDefaultPolicy?: CfnPolicy;
}

// @public (undocumented)
export enum QueryFieldType {
    // (undocumented)
    GET = "GET",
    // (undocumented)
    LIST = "LIST",
    // (undocumented)
    SYNC = "SYNC"
}

// @public (undocumented)
export type RDSLayerMapping = {
    [key: string]: {
        layerRegion: string;
    };
};

// @public (undocumented)
type ReadonlyArray_2<T> = Readonly<Array<Readonly<T>>>;
export { ReadonlyArray_2 as ReadonlyArray }

// @public (undocumented)
export type ResolverReferenceEntry = {
    typeName: string;
    fieldName: string;
    isList: boolean;
};

// @public (undocumented)
export interface ResolversFunctionsAndSchema {
    // (undocumented)
    functions: Record<string, string>;
    // (undocumented)
    pipelineFunctions: Record<string, string>;
    // (undocumented)
    resolvers: Record<string, string>;
    // (undocumented)
    schema: string;
    // (undocumented)
    userOverriddenSlots: string[];
}

// @public (undocumented)
export interface S3MappingFunctionCodeProvider {
    // (undocumented)
    bind: (scope: Construct) => IAsset;
    // (undocumented)
    type: MappingTemplateType.S3_LOCATION;
}

// @public (undocumented)
export interface S3MappingTemplateProvider {
    // (undocumented)
    bind: (scope: Construct) => string;
    // (undocumented)
    getTemplateHash: () => string;
    // (undocumented)
    type: MappingTemplateType.S3_LOCATION;
}

// @public (undocumented)
export interface SearchableDataSourceOptions extends DataSourceOptions {
    // (undocumented)
    readonly serviceRole: IRole;
}

// @public (undocumented)
export interface StackManagerProvider {
    // (undocumented)
    addParameter: (name: string, props: CfnParameterProps) => CfnParameter;
    // (undocumented)
    createStack: (stackName: string) => Stack;
    // (undocumented)
    getParameter: (name: string) => CfnParameter | void;
    // (undocumented)
    getStack: (stackName: string) => Stack;
    // (undocumented)
    getStackFor: (resourceId: string, defaultStackName?: string) => Stack;
    // (undocumented)
    hasStack: (stackName: string) => boolean;
    // (undocumented)
    readonly rootStack: Stack;
}

// @public (undocumented)
export interface StackMapping {
    // (undocumented)
    [resourceId: string]: string;
}

// @public (undocumented)
export enum SubscriptionFieldType {
    // (undocumented)
    ON_CREATE = "ON_CREATE",
    // (undocumented)
    ON_DELETE = "ON_DELETE",
    // (undocumented)
    ON_UPDATE = "ON_UPDATE"
}

// @public (undocumented)
export interface Template {
    // (undocumented)
    AWSTemplateFormatVersion?: string;
    // (undocumented)
    Conditions?: Record<string, any>;
    // (undocumented)
    Description?: string;
    // (undocumented)
    Mappings?: {
        [key: string]: {
            [key: string]: Record<string, string | number | string[]>;
        };
    };
    // (undocumented)
    Metadata?: Record<string, any>;
    // (undocumented)
    Outputs?: Record<string, any>;
    // (undocumented)
    Parameters?: Record<string, any>;
    // (undocumented)
    Resources?: Record<string, any>;
    // (undocumented)
    Transform?: any;
}

// @public (undocumented)
export type TransformerAuthProvider = TransformerPluginProvider;

// @public (undocumented)
export type TransformerBeforeStepContextProvider = Pick<TransformerContextProvider, 'inputDocument' | 'modelToDatasourceMap' | 'transformParameters' | 'isProjectUsingDataStore' | 'getResolverConfig' | 'authConfig' | 'stackManager'>;

// @public (undocumented)
export interface TransformerContextOutputProvider {
    // (undocumented)
    addEnum(en: EnumTypeDefinitionNode): void;
    // (undocumented)
    addEnumExtension(obj: EnumTypeExtensionNode): void;
    // (undocumented)
    addInput(inp: InputObjectTypeDefinitionNode): void;
    // (undocumented)
    addInputExtension(obj: InputObjectTypeExtensionNode): void;
    // (undocumented)
    addInterfaceExtension(obj: InterfaceTypeExtensionNode): void;
    // (undocumented)
    addMutationFields(fields: FieldDefinitionNode[]): void;
    // (undocumented)
    addObject(obj: ObjectTypeDefinitionNode): void;
    // (undocumented)
    addObjectExtension(obj: ObjectTypeExtensionNode): void;
    // (undocumented)
    addQueryFields(fields: FieldDefinitionNode[]): void;
    // (undocumented)
    addSubscriptionFields(fields: FieldDefinitionNode[]): void;
    // (undocumented)
    addType(obj: TypeDefinitionNode): void;
    // (undocumented)
    addUnion(obj: UnionTypeDefinitionNode): void;
    // (undocumented)
    addUnionExtension(obj: UnionTypeExtensionNode): void;
    // (undocumented)
    getMutation(): ObjectTypeDefinitionNode | undefined;
    // (undocumented)
    getMutationTypeName(): string | undefined;
    // (undocumented)
    getObject(name: string): ObjectTypeDefinitionNode | undefined;
    // (undocumented)
    getQuery(): ObjectTypeDefinitionNode | undefined;
    // (undocumented)
    getQueryTypeName: () => string | undefined;
    // (undocumented)
    getSchema: () => SchemaDefinitionNode;
    // (undocumented)
    getSubscription(): ObjectTypeDefinitionNode | undefined;
    // (undocumented)
    getSubscriptionTypeName(): string | undefined;
    // (undocumented)
    getType(name: string): TypeSystemDefinitionNode | undefined;
    // (undocumented)
    getTypeDefinitionsOfKind: (kind: string) => TypeDefinitionNode[];
    // (undocumented)
    hasType(name: string): boolean;
    // (undocumented)
    putSchema: (obj: SchemaDefinitionNode) => void;
    // (undocumented)
    putType(obj: TypeDefinitionNode): void;
    // (undocumented)
    updateObject(obj: ObjectTypeDefinitionNode): void;
}

// @public (undocumented)
export interface TransformerContextProvider {
    // (undocumented)
    api: GraphQLAPIProvider;
    // (undocumented)
    authConfig: AppSyncAuthConfiguration;
    // (undocumented)
    dataSources: TransformerDataSourceManagerProvider;
    // (undocumented)
    datasourceSecretParameterLocations: Map<string, TransformerSecrets>;
    // (undocumented)
    getResolverConfig<ResolverConfig>(): ResolverConfig | undefined;
    // (undocumented)
    inputDocument: DocumentNode;
    // (undocumented)
    isProjectUsingDataStore(): boolean;
    // Warning: (ae-forgotten-export) The symbol "TransformerContextMetadataProvider" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    metadata: TransformerContextMetadataProvider;
    // Warning: (ae-forgotten-export) The symbol "DatasourceType" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    modelToDatasourceMap: Map<string, DatasourceType>;
    // (undocumented)
    output: TransformerContextOutputProvider;
    // (undocumented)
    providerRegistry: TransformerProviderRegistry;
    // (undocumented)
    readonly rdsLayerMapping?: RDSLayerMapping;
    // (undocumented)
    resolvers: TransformerResolversManagerProvider;
    // (undocumented)
    resourceHelper: TransformerResourceHelperProvider;
    // (undocumented)
    readonly sqlLambdaVpcConfig?: VpcConfig;
    // (undocumented)
    stackManager: StackManagerProvider;
    // (undocumented)
    transformParameters: TransformParameters;
}

// @public (undocumented)
export interface TransformerDataSourceManagerProvider {
    // (undocumented)
    add(type: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode, dataSourceInstance: DataSourceInstance): void;
    // (undocumented)
    get(type: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode): DataSourceInstance;
    // (undocumented)
    has(name: string): boolean;
}

// @public (undocumented)
export type TransformerLog = {
    message: string;
    level: TransformerLogLevel;
};

// @public (undocumented)
export enum TransformerLogLevel {
    // (undocumented)
    DEBUG = "DEBUG",
    // (undocumented)
    ERROR = "ERROR",
    // (undocumented)
    INFO = "INFO",
    // (undocumented)
    WARN = "WARN"
}

// @public (undocumented)
export type TransformerModelEnhancementProvider = Partial<TransformerModelProvider>;

// @public (undocumented)
export interface TransformerModelProvider extends TransformerPluginProvider {
    // (undocumented)
    generateCreateResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    generateDeleteResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    generateGetResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    generateListResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    generateOnCreateResolver?: (ctx: TransformerContextProvider, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    generateOnDeleteResolver?: (ctx: TransformerContextProvider, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    generateOnUpdateResolver?: (ctx: TransformerContextProvider, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    generateSyncResolver?: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    generateUpdateResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    getDataSourceResource: (type: ObjectTypeDefinitionNode) => DataSourceInstance;
    // (undocumented)
    getDataSourceType: () => AppSyncDataSourceType;
    // (undocumented)
    getInputs: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, operation: {
        fieldName: string;
        typeName: string;
        type: QueryFieldType | MutationFieldType | SubscriptionFieldType;
    }) => InputValueDefinitionNode[];
    // (undocumented)
    getMutationFieldNames: (type: ObjectTypeDefinitionNode, directive?: DirectiveDefinitionNode) => Set<{
        fieldName: string;
        typeName: string;
        type: MutationFieldType;
    }>;
    // (undocumented)
    getOutputType: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, operation: {
        fieldName: string;
        typeName: string;
        type: QueryFieldType | MutationFieldType | SubscriptionFieldType;
    }) => ObjectTypeDefinitionNode;
    // (undocumented)
    getQueryFieldNames: (type: ObjectTypeDefinitionNode, directive?: DirectiveDefinitionNode) => Set<{
        fieldName: string;
        typeName: string;
        type: QueryFieldType;
    }>;
    // (undocumented)
    getSubscriptionFieldNames: (type: ObjectTypeDefinitionNode, directive?: DirectiveDefinitionNode) => Set<{
        fieldName: string;
        typeName: string;
        type: SubscriptionFieldType;
    }>;
}

// @public (undocumented)
export interface TransformerPluginProvider {
    // (undocumented)
    after?: (context: TransformerContextProvider) => void;
    // (undocumented)
    argument?: (definition: InputValueDefinitionNode, directive: DirectiveNode, context: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    before?: (context: TransformerBeforeStepContextProvider) => void;
    // (undocumented)
    readonly directive: DirectiveDefinitionNode;
    // (undocumented)
    enum?: (definition: EnumTypeDefinitionNode, directive: DirectiveNode, context: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    enumValue?: (definition: EnumValueDefinitionNode, directive: DirectiveNode, context: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    field?: (parent: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode, definition: FieldDefinitionNode, directive: DirectiveNode, acc: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    generateResolvers?: (context: TransformerContextProvider) => void;
    // (undocumented)
    getLogs?: () => TransformerLog[];
    // (undocumented)
    input?: (definition: InputObjectTypeDefinitionNode, directive: DirectiveNode, context: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    inputValue?: (definition: InputValueDefinitionNode, directive: DirectiveNode, context: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    interface?: (definition: InterfaceTypeDefinitionNode, directive: DirectiveNode, acc: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    mutateSchema?: (context: TransformerPreProcessContextProvider) => DocumentNode;
    // (undocumented)
    name: string;
    // (undocumented)
    object?: (definition: ObjectTypeDefinitionNode, directive: DirectiveNode, acc: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    pluginType: TransformerPluginType;
    // (undocumented)
    preMutateSchema?: (context: TransformerPreProcessContextProvider) => void;
    // (undocumented)
    prepare?: (context: TransformerPrepareStepContextProvider) => void;
    // (undocumented)
    scalar?: (definition: ScalarTypeDefinitionNode, directive: DirectiveNode, context: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    transformSchema?: (context: TransformerTransformSchemaStepContextProvider) => void;
    // (undocumented)
    typeDefinitions: TypeDefinitionNode[];
    // (undocumented)
    union?: (definition: UnionTypeDefinitionNode, directive: DirectiveNode, context: TransformerSchemaVisitStepContextProvider) => void;
    // (undocumented)
    validate?: (context: TransformerValidationStepContextProvider) => void;
}

// @public (undocumented)
export enum TransformerPluginType {
    // (undocumented)
    AUTH = "AUTH",
    // (undocumented)
    DATA_SOURCE_ENHANCER = "DATA_SOURCE_ENHANCER",
    // (undocumented)
    DATA_SOURCE_PROVIDER = "DATA_SOURCE_PROVIDER",
    // (undocumented)
    GENERIC = "GENERIC"
}

// @public (undocumented)
export type TransformerPrepareStepContextProvider = TransformerValidationStepContextProvider;

// @public (undocumented)
export interface TransformerPreProcessContextProvider {
    // (undocumented)
    inputDocument: DocumentNode;
    // (undocumented)
    schemaHelper: TransformerSchemaHelperProvider;
    // (undocumented)
    transformParameters: TransformParameters;
}

// @public (undocumented)
export interface TransformerProviderRegistry {
    // (undocumented)
    addDataSourceEnhancer: (type: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode, provider: TransformerModelEnhancementProvider) => void;
    // (undocumented)
    getDataSourceEnhancers: (type: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode) => TransformerModelEnhancementProvider[];
    // (undocumented)
    getDataSourceProvider(type: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode): TransformerModelProvider;
    // (undocumented)
    hasDataSourceProvider(type: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode): boolean;
    // (undocumented)
    registerDataSourceProvider: (type: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode, provider: TransformerModelProvider) => void;
}

// @public (undocumented)
export interface TransformerResolverProvider {
    // (undocumented)
    addToSlot: (slotName: string, requestMappingTemplate?: MappingTemplateProvider, responseMappingTemplate?: MappingTemplateProvider, dataSource?: DataSourceProvider) => void;
    // (undocumented)
    mapToStack: (stack: Stack) => void;
    // (undocumented)
    synthesize: (context: TransformerContextProvider, api: GraphQLAPIProvider) => void;
}

// @public (undocumented)
export interface TransformerResolversManagerProvider {
    // (undocumented)
    addResolver: (typeName: string, fieldName: string, resolver: TransformerResolverProvider) => TransformerResolverProvider;
    // (undocumented)
    collectResolvers: () => Map<string, TransformerResolverProvider>;
    // (undocumented)
    generateMutationResolver: (typeName: string, fieldName: string, resolverLogicalId: string, dataSource: DataSourceProvider, requestMappingTemplate: MappingTemplateProvider, responseMappingTemplate: MappingTemplateProvider) => TransformerResolverProvider;
    // (undocumented)
    generateQueryResolver: (typeName: string, fieldName: string, resolverLogicalId: string, dataSource: DataSourceProvider, requestMappingTemplate: MappingTemplateProvider, responseMappingTemplate: MappingTemplateProvider) => TransformerResolverProvider;
    // (undocumented)
    generateSubscriptionResolver: (typeName: string, fieldName: string, resolverLogicalId: string, requestMappingTemplate: MappingTemplateProvider, responseMappingTemplate: MappingTemplateProvider) => TransformerResolverProvider;
    // (undocumented)
    getResolver: (typeName: string, fieldName: string) => TransformerResolverProvider | void;
    // (undocumented)
    hasResolver: (typeName: string, fieldName: string) => boolean;
    // (undocumented)
    removeResolver: (typeName: string, fieldName: string) => TransformerResolverProvider;
}

// @public (undocumented)
export interface TransformerResourceHelperProvider {
    // (undocumented)
    addDirectiveConfigExclusion(object: ObjectTypeDefinitionNode | ObjectTypeExtensionNode, field: FieldNode, directive: DirectiveNode): void;
    // (undocumented)
    generateIAMRoleName(name: string): string;
    // (undocumented)
    generateTableName(modelName: string): string;
    // (undocumented)
    getFieldNameMapping(modelName: string, fieldName: string): string;
    // (undocumented)
    getModelFieldMap(modelName: string): ModelFieldMap;
    // (undocumented)
    getModelFieldMapKeys(): string[];
    // (undocumented)
    getModelNameMapping(modelName: string): string;
    // (undocumented)
    isDirectiveConfigExcluded(object: ObjectTypeExtensionNode | ObjectTypeExtensionNode, field: FieldNode, directive: DirectiveNode): boolean;
    // (undocumented)
    isModelRenamed(modelName: string): boolean;
    // (undocumented)
    setModelNameMapping(modelName: string, mappedName: string): void;
}

// @public (undocumented)
export interface TransformerSchemaHelperProvider {
    // (undocumented)
    getTypeMapping: (newTypeName: string) => string;
    // (undocumented)
    setTypeMapping: (newTypeName: string, originalTypeName: string) => void;
}

// @public (undocumented)
export type TransformerSchemaVisitStepContextProvider = Pick<TransformerContextProvider, 'inputDocument' | 'modelToDatasourceMap' | 'output' | 'providerRegistry' | 'transformParameters' | 'isProjectUsingDataStore' | 'getResolverConfig' | 'metadata' | 'authConfig' | 'resourceHelper'>;

// @public (undocumented)
export type TransformerSecrets = {
    [key: string]: any;
};

// @public (undocumented)
export type TransformerTransformSchemaStepContextProvider = TransformerValidationStepContextProvider;

// @public (undocumented)
export type TransformerValidationStepContextProvider = Pick<TransformerContextProvider, 'inputDocument' | 'modelToDatasourceMap' | 'output' | 'providerRegistry' | 'dataSources' | 'transformParameters' | 'isProjectUsingDataStore' | 'getResolverConfig' | 'metadata' | 'authConfig' | 'resourceHelper' | 'resolvers' | 'stackManager'>;

// @public (undocumented)
export interface TransformHostProvider {
    // (undocumented)
    addAppSyncFunction: (name: string, requestMappingTemplate: MappingTemplateProvider, responseMappingTemplate: MappingTemplateProvider, dataSourceName: string, stack?: Stack) => AppSyncFunctionConfigurationProvider;
    // (undocumented)
    addDynamoDbDataSource(name: string, table: ITable, options?: DynamoDbDataSourceOptions, stack?: Stack): DynamoDbDataSource;
    // (undocumented)
    addHttpDataSource(name: string, endpoint: string, options?: DataSourceOptions, stack?: Stack): HttpDataSource;
    // (undocumented)
    addLambdaDataSource(name: string, lambdaFunction: IFunction, options?: DataSourceOptions, stack?: Stack): LambdaDataSource;
    // (undocumented)
    addLambdaFunction: (functionName: string, functionKey: string, handlerName: string, filePath: string, runtime: Runtime, layers?: ILayerVersion[], role?: IRole, environment?: {
        [key: string]: string;
    }, timeout?: Duration, stack?: Stack, vpc?: VpcConfig) => IFunction;
    // (undocumented)
    addNoneDataSource(name: string, options?: DataSourceOptions, stack?: Stack): NoneDataSource;
    // (undocumented)
    addResolver: (typeName: string, fieldName: string, requestMappingTemplate: MappingTemplateProvider, responseMappingTemplate: MappingTemplateProvider, resolverLogicalId?: string, dataSourceName?: string, pipelineConfig?: string[], stack?: Stack) => CfnResolver;
    // (undocumented)
    addSearchableDataSource(name: string, endpoint: string, region: string, options?: SearchableDataSourceOptions, stack?: Stack): BaseDataSource;
    // (undocumented)
    getDataSource: (name: string) => BaseDataSource | void;
    // (undocumented)
    getResolver: (typeName: string, fieldName: string) => CfnResolver | void;
    // (undocumented)
    hasDataSource: (name: string) => boolean;
    // (undocumented)
    hasResolver: (typeName: string, fieldName: string) => boolean;
    // (undocumented)
    setAPI(api: GraphqlApiBase): void;
}

// @public (undocumented)
export type TransformParameters = {
    shouldDeepMergeDirectiveConfigDefaults: boolean;
    disableResolverDeduping: boolean;
    sandboxModeEnabled: boolean;
    useSubUsernameForDefaultIdentityClaim: boolean;
    populateOwnerFieldForStaticGroupAuth: boolean;
    suppressApiKeyGeneration: boolean;
    secondaryKeyAsGSI: boolean;
    enableAutoIndexQueryNames: boolean;
    respectPrimaryKeyAttributesOnConnectionField: boolean;
    enableSearchNodeToNodeEncryption: boolean;
};

// @public (undocumented)
export interface UserPoolConfig {
    // (undocumented)
    userPoolId: string;
}

// @public (undocumented)
export type VpcConfig = {
    vpcId: string;
    subnetIds: string[];
    securityGroupIds: string[];
};

// Warnings were encountered during analysis:
//
// src/graphql-api-provider.ts:34:3 - (ae-forgotten-export) The symbol "OpenIDConnectConfig" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)

```