resolver.go

Documentation: github.com/99designs/gqlgen/codegen/testserver/singlefile

     1  package singlefile
     2  
     3  // THIS CODE IS A STARTING POINT ONLY. IT WILL NOT BE UPDATED WITH SCHEMA CHANGES.
     4  
     5  import (
     6  	"context"
     7  
     8  	introspection1 "github.com/99designs/gqlgen/codegen/testserver/singlefile/introspection"
     9  	invalid_packagename "github.com/99designs/gqlgen/codegen/testserver/singlefile/invalid-packagename"
    10  	"github.com/99designs/gqlgen/codegen/testserver/singlefile/otherpkg"
    11  )
    12  
    13  type Resolver struct{}
    14  
    15  // ID is the resolver for the id field.
    16  func (r *backedByInterfaceResolver) ID(ctx context.Context, obj BackedByInterface) (string, error) {
    17  	panic("not implemented")
    18  }
    19  
    20  // Values is the resolver for the values field.
    21  func (r *deferModelResolver) Values(ctx context.Context, obj *DeferModel) ([]string, error) {
    22  	panic("not implemented")
    23  }
    24  
    25  // A is the resolver for the a field.
    26  func (r *errorsResolver) A(ctx context.Context, obj *Errors) (*Error, error) {
    27  	panic("not implemented")
    28  }
    29  
    30  // B is the resolver for the b field.
    31  func (r *errorsResolver) B(ctx context.Context, obj *Errors) (*Error, error) {
    32  	panic("not implemented")
    33  }
    34  
    35  // C is the resolver for the c field.
    36  func (r *errorsResolver) C(ctx context.Context, obj *Errors) (*Error, error) {
    37  	panic("not implemented")
    38  }
    39  
    40  // D is the resolver for the d field.
    41  func (r *errorsResolver) D(ctx context.Context, obj *Errors) (*Error, error) {
    42  	panic("not implemented")
    43  }
    44  
    45  // E is the resolver for the e field.
    46  func (r *errorsResolver) E(ctx context.Context, obj *Errors) (*Error, error) {
    47  	panic("not implemented")
    48  }
    49  
    50  // Field is the resolver for the field field.
    51  func (r *forcedResolverResolver) Field(ctx context.Context, obj *ForcedResolver) (*Circle, error) {
    52  	panic("not implemented")
    53  }
    54  
    55  // ResolverField is the resolver for the resolverField field.
    56  func (r *modelMethodsResolver) ResolverField(ctx context.Context, obj *ModelMethods) (bool, error) {
    57  	panic("not implemented")
    58  }
    59  
    60  // DefaultInput is the resolver for the defaultInput field.
    61  func (r *mutationResolver) DefaultInput(ctx context.Context, input DefaultInput) (*DefaultParametersMirror, error) {
    62  	panic("not implemented")
    63  }
    64  
    65  // OverrideValueViaInput is the resolver for the overrideValueViaInput field.
    66  func (r *mutationResolver) OverrideValueViaInput(ctx context.Context, input FieldsOrderInput) (*FieldsOrderPayload, error) {
    67  	panic("not implemented")
    68  }
    69  
    70  // UpdateSomething is the resolver for the updateSomething field.
    71  func (r *mutationResolver) UpdateSomething(ctx context.Context, input SpecialInput) (string, error) {
    72  	panic("not implemented")
    73  }
    74  
    75  // UpdatePtrToPtr is the resolver for the updatePtrToPtr field.
    76  func (r *mutationResolver) UpdatePtrToPtr(ctx context.Context, input UpdatePtrToPtrOuter) (*PtrToPtrOuter, error) {
    77  	panic("not implemented")
    78  }
    79  
    80  // OldFoo is the resolver for the oldFoo field.
    81  func (r *overlappingFieldsResolver) OldFoo(ctx context.Context, obj *OverlappingFields) (int, error) {
    82  	panic("not implemented")
    83  }
    84  
    85  // FieldScalarMarshal is the resolver for the fieldScalarMarshal field.
    86  func (r *panicsResolver) FieldScalarMarshal(ctx context.Context, obj *Panics) ([]MarshalPanic, error) {
    87  	panic("not implemented")
    88  }
    89  
    90  // ArgUnmarshal is the resolver for the argUnmarshal field.
    91  func (r *panicsResolver) ArgUnmarshal(ctx context.Context, obj *Panics, u []MarshalPanic) (bool, error) {
    92  	panic("not implemented")
    93  }
    94  
    95  // Friends is the resolver for the friends field.
    96  func (r *petResolver) Friends(ctx context.Context, obj *Pet, limit *int) ([]*Pet, error) {
    97  	panic("not implemented")
    98  }
    99  
   100  // Value is the resolver for the value field.
   101  func (r *primitiveResolver) Value(ctx context.Context, obj *Primitive) (int, error) {
   102  	panic("not implemented")
   103  }
   104  
   105  // Value is the resolver for the value field.
   106  func (r *primitiveStringResolver) Value(ctx context.Context, obj *PrimitiveString) (string, error) {
   107  	panic("not implemented")
   108  }
   109  
   110  // Len is the resolver for the len field.
   111  func (r *primitiveStringResolver) Len(ctx context.Context, obj *PrimitiveString) (int, error) {
   112  	panic("not implemented")
   113  }
   114  
   115  // InvalidIdentifier is the resolver for the invalidIdentifier field.
   116  func (r *queryResolver) InvalidIdentifier(ctx context.Context) (*invalid_packagename.InvalidIdentifier, error) {
   117  	panic("not implemented")
   118  }
   119  
   120  // Collision is the resolver for the collision field.
   121  func (r *queryResolver) Collision(ctx context.Context) (*introspection1.It, error) {
   122  	panic("not implemented")
   123  }
   124  
   125  // MapInput is the resolver for the mapInput field.
   126  func (r *queryResolver) MapInput(ctx context.Context, input map[string]interface{}) (*bool, error) {
   127  	panic("not implemented")
   128  }
   129  
   130  // Recursive is the resolver for the recursive field.
   131  func (r *queryResolver) Recursive(ctx context.Context, input *RecursiveInputSlice) (*bool, error) {
   132  	panic("not implemented")
   133  }
   134  
   135  // NestedInputs is the resolver for the nestedInputs field.
   136  func (r *queryResolver) NestedInputs(ctx context.Context, input [][]*OuterInput) (*bool, error) {
   137  	panic("not implemented")
   138  }
   139  
   140  // NestedOutputs is the resolver for the nestedOutputs field.
   141  func (r *queryResolver) NestedOutputs(ctx context.Context) ([][]*OuterObject, error) {
   142  	panic("not implemented")
   143  }
   144  
   145  // ModelMethods is the resolver for the modelMethods field.
   146  func (r *queryResolver) ModelMethods(ctx context.Context) (*ModelMethods, error) {
   147  	panic("not implemented")
   148  }
   149  
   150  // User is the resolver for the user field.
   151  func (r *queryResolver) User(ctx context.Context, id int) (*User, error) {
   152  	panic("not implemented")
   153  }
   154  
   155  // NullableArg is the resolver for the nullableArg field.
   156  func (r *queryResolver) NullableArg(ctx context.Context, arg *int) (*string, error) {
   157  	panic("not implemented")
   158  }
   159  
   160  // InputSlice is the resolver for the inputSlice field.
   161  func (r *queryResolver) InputSlice(ctx context.Context, arg []string) (bool, error) {
   162  	panic("not implemented")
   163  }
   164  
   165  // InputNullableSlice is the resolver for the inputNullableSlice field.
   166  func (r *queryResolver) InputNullableSlice(ctx context.Context, arg []string) (bool, error) {
   167  	panic("not implemented")
   168  }
   169  
   170  // InputOmittable is the resolver for the inputOmittable field.
   171  func (r *queryResolver) InputOmittable(ctx context.Context, arg OmittableInput) (string, error) {
   172  	panic("not implemented")
   173  }
   174  
   175  // ShapeUnion is the resolver for the shapeUnion field.
   176  func (r *queryResolver) ShapeUnion(ctx context.Context) (ShapeUnion, error) {
   177  	panic("not implemented")
   178  }
   179  
   180  // Autobind is the resolver for the autobind field.
   181  func (r *queryResolver) Autobind(ctx context.Context) (*Autobind, error) {
   182  	panic("not implemented")
   183  }
   184  
   185  // DeprecatedField is the resolver for the deprecatedField field.
   186  func (r *queryResolver) DeprecatedField(ctx context.Context) (string, error) {
   187  	panic("not implemented")
   188  }
   189  
   190  // Overlapping is the resolver for the overlapping field.
   191  func (r *queryResolver) Overlapping(ctx context.Context) (*OverlappingFields, error) {
   192  	panic("not implemented")
   193  }
   194  
   195  // DefaultParameters is the resolver for the defaultParameters field.
   196  func (r *queryResolver) DefaultParameters(ctx context.Context, falsyBoolean *bool, truthyBoolean *bool) (*DefaultParametersMirror, error) {
   197  	panic("not implemented")
   198  }
   199  
   200  // DeferCase1 is the resolver for the deferCase1 field.
   201  func (r *queryResolver) DeferCase1(ctx context.Context) (*DeferModel, error) {
   202  	panic("not implemented")
   203  }
   204  
   205  // DeferCase2 is the resolver for the deferCase2 field.
   206  func (r *queryResolver) DeferCase2(ctx context.Context) ([]*DeferModel, error) {
   207  	panic("not implemented")
   208  }
   209  
   210  // DirectiveArg is the resolver for the directiveArg field.
   211  func (r *queryResolver) DirectiveArg(ctx context.Context, arg string) (*string, error) {
   212  	panic("not implemented")
   213  }
   214  
   215  // DirectiveNullableArg is the resolver for the directiveNullableArg field.
   216  func (r *queryResolver) DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (*string, error) {
   217  	panic("not implemented")
   218  }
   219  
   220  // DirectiveInputNullable is the resolver for the directiveInputNullable field.
   221  func (r *queryResolver) DirectiveInputNullable(ctx context.Context, arg *InputDirectives) (*string, error) {
   222  	panic("not implemented")
   223  }
   224  
   225  // DirectiveInput is the resolver for the directiveInput field.
   226  func (r *queryResolver) DirectiveInput(ctx context.Context, arg InputDirectives) (*string, error) {
   227  	panic("not implemented")
   228  }
   229  
   230  // DirectiveInputType is the resolver for the directiveInputType field.
   231  func (r *queryResolver) DirectiveInputType(ctx context.Context, arg InnerInput) (*string, error) {
   232  	panic("not implemented")
   233  }
   234  
   235  // DirectiveObject is the resolver for the directiveObject field.
   236  func (r *queryResolver) DirectiveObject(ctx context.Context) (*ObjectDirectives, error) {
   237  	panic("not implemented")
   238  }
   239  
   240  // DirectiveObjectWithCustomGoModel is the resolver for the directiveObjectWithCustomGoModel field.
   241  func (r *queryResolver) DirectiveObjectWithCustomGoModel(ctx context.Context) (*ObjectDirectivesWithCustomGoModel, error) {
   242  	panic("not implemented")
   243  }
   244  
   245  // DirectiveFieldDef is the resolver for the directiveFieldDef field.
   246  func (r *queryResolver) DirectiveFieldDef(ctx context.Context, ret string) (string, error) {
   247  	panic("not implemented")
   248  }
   249  
   250  // DirectiveField is the resolver for the directiveField field.
   251  func (r *queryResolver) DirectiveField(ctx context.Context) (*string, error) {
   252  	panic("not implemented")
   253  }
   254  
   255  // DirectiveDouble is the resolver for the directiveDouble field.
   256  func (r *queryResolver) DirectiveDouble(ctx context.Context) (*string, error) {
   257  	panic("not implemented")
   258  }
   259  
   260  // DirectiveUnimplemented is the resolver for the directiveUnimplemented field.
   261  func (r *queryResolver) DirectiveUnimplemented(ctx context.Context) (*string, error) {
   262  	panic("not implemented")
   263  }
   264  
   265  // EmbeddedCase1 is the resolver for the embeddedCase1 field.
   266  func (r *queryResolver) EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error) {
   267  	panic("not implemented")
   268  }
   269  
   270  // EmbeddedCase2 is the resolver for the embeddedCase2 field.
   271  func (r *queryResolver) EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error) {
   272  	panic("not implemented")
   273  }
   274  
   275  // EmbeddedCase3 is the resolver for the embeddedCase3 field.
   276  func (r *queryResolver) EmbeddedCase3(ctx context.Context) (*EmbeddedCase3, error) {
   277  	panic("not implemented")
   278  }
   279  
   280  // EnumInInput is the resolver for the enumInInput field.
   281  func (r *queryResolver) EnumInInput(ctx context.Context, input *InputWithEnumValue) (EnumTest, error) {
   282  	panic("not implemented")
   283  }
   284  
   285  // Shapes is the resolver for the shapes field.
   286  func (r *queryResolver) Shapes(ctx context.Context) ([]Shape, error) {
   287  	panic("not implemented")
   288  }
   289  
   290  // NoShape is the resolver for the noShape field.
   291  func (r *queryResolver) NoShape(ctx context.Context) (Shape, error) {
   292  	panic("not implemented")
   293  }
   294  
   295  // Node is the resolver for the node field.
   296  func (r *queryResolver) Node(ctx context.Context) (Node, error) {
   297  	panic("not implemented")
   298  }
   299  
   300  // NoShapeTypedNil is the resolver for the noShapeTypedNil field.
   301  func (r *queryResolver) NoShapeTypedNil(ctx context.Context) (Shape, error) {
   302  	panic("not implemented")
   303  }
   304  
   305  // Animal is the resolver for the animal field.
   306  func (r *queryResolver) Animal(ctx context.Context) (Animal, error) {
   307  	panic("not implemented")
   308  }
   309  
   310  // NotAnInterface is the resolver for the notAnInterface field.
   311  func (r *queryResolver) NotAnInterface(ctx context.Context) (BackedByInterface, error) {
   312  	panic("not implemented")
   313  }
   314  
   315  // Dog is the resolver for the dog field.
   316  func (r *queryResolver) Dog(ctx context.Context) (*Dog, error) {
   317  	panic("not implemented")
   318  }
   319  
   320  // Issue896a is the resolver for the issue896a field.
   321  func (r *queryResolver) Issue896a(ctx context.Context) ([]*CheckIssue896, error) {
   322  	panic("not implemented")
   323  }
   324  
   325  // MapStringInterface is the resolver for the mapStringInterface field.
   326  func (r *queryResolver) MapStringInterface(ctx context.Context, in map[string]interface{}) (map[string]interface{}, error) {
   327  	panic("not implemented")
   328  }
   329  
   330  // MapNestedStringInterface is the resolver for the mapNestedStringInterface field.
   331  func (r *queryResolver) MapNestedStringInterface(ctx context.Context, in *NestedMapInput) (map[string]interface{}, error) {
   332  	panic("not implemented")
   333  }
   334  
   335  // ErrorBubble is the resolver for the errorBubble field.
   336  func (r *queryResolver) ErrorBubble(ctx context.Context) (*Error, error) {
   337  	panic("not implemented")
   338  }
   339  
   340  // ErrorBubbleList is the resolver for the errorBubbleList field.
   341  func (r *queryResolver) ErrorBubbleList(ctx context.Context) ([]*Error, error) {
   342  	panic("not implemented")
   343  }
   344  
   345  // ErrorList is the resolver for the errorList field.
   346  func (r *queryResolver) ErrorList(ctx context.Context) ([]*Error, error) {
   347  	panic("not implemented")
   348  }
   349  
   350  // Errors is the resolver for the errors field.
   351  func (r *queryResolver) Errors(ctx context.Context) (*Errors, error) {
   352  	panic("not implemented")
   353  }
   354  
   355  // Valid is the resolver for the valid field.
   356  func (r *queryResolver) Valid(ctx context.Context) (string, error) {
   357  	panic("not implemented")
   358  }
   359  
   360  // Invalid is the resolver for the invalid field.
   361  func (r *queryResolver) Invalid(ctx context.Context) (string, error) {
   362  	panic("not implemented")
   363  }
   364  
   365  // Panics is the resolver for the panics field.
   366  func (r *queryResolver) Panics(ctx context.Context) (*Panics, error) {
   367  	panic("not implemented")
   368  }
   369  
   370  // PrimitiveObject is the resolver for the primitiveObject field.
   371  func (r *queryResolver) PrimitiveObject(ctx context.Context) ([]Primitive, error) {
   372  	panic("not implemented")
   373  }
   374  
   375  // PrimitiveStringObject is the resolver for the primitiveStringObject field.
   376  func (r *queryResolver) PrimitiveStringObject(ctx context.Context) ([]PrimitiveString, error) {
   377  	panic("not implemented")
   378  }
   379  
   380  // PtrToAnyContainer is the resolver for the ptrToAnyContainer field.
   381  func (r *queryResolver) PtrToAnyContainer(ctx context.Context) (*PtrToAnyContainer, error) {
   382  	panic("not implemented")
   383  }
   384  
   385  // PtrToSliceContainer is the resolver for the ptrToSliceContainer field.
   386  func (r *queryResolver) PtrToSliceContainer(ctx context.Context) (*PtrToSliceContainer, error) {
   387  	panic("not implemented")
   388  }
   389  
   390  // Infinity is the resolver for the infinity field.
   391  func (r *queryResolver) Infinity(ctx context.Context) (float64, error) {
   392  	panic("not implemented")
   393  }
   394  
   395  // StringFromContextInterface is the resolver for the stringFromContextInterface field.
   396  func (r *queryResolver) StringFromContextInterface(ctx context.Context) (*StringFromContextInterface, error) {
   397  	panic("not implemented")
   398  }
   399  
   400  // StringFromContextFunction is the resolver for the stringFromContextFunction field.
   401  func (r *queryResolver) StringFromContextFunction(ctx context.Context) (string, error) {
   402  	panic("not implemented")
   403  }
   404  
   405  // DefaultScalar is the resolver for the defaultScalar field.
   406  func (r *queryResolver) DefaultScalar(ctx context.Context, arg string) (string, error) {
   407  	panic("not implemented")
   408  }
   409  
   410  // Slices is the resolver for the slices field.
   411  func (r *queryResolver) Slices(ctx context.Context) (*Slices, error) {
   412  	panic("not implemented")
   413  }
   414  
   415  // ScalarSlice is the resolver for the scalarSlice field.
   416  func (r *queryResolver) ScalarSlice(ctx context.Context) ([]byte, error) {
   417  	panic("not implemented")
   418  }
   419  
   420  // Fallback is the resolver for the fallback field.
   421  func (r *queryResolver) Fallback(ctx context.Context, arg FallbackToStringEncoding) (FallbackToStringEncoding, error) {
   422  	panic("not implemented")
   423  }
   424  
   425  // OptionalUnion is the resolver for the optionalUnion field.
   426  func (r *queryResolver) OptionalUnion(ctx context.Context) (TestUnion, error) {
   427  	panic("not implemented")
   428  }
   429  
   430  // VOkCaseValue is the resolver for the vOkCaseValue field.
   431  func (r *queryResolver) VOkCaseValue(ctx context.Context) (*VOkCaseValue, error) {
   432  	panic("not implemented")
   433  }
   434  
   435  // VOkCaseNil is the resolver for the vOkCaseNil field.
   436  func (r *queryResolver) VOkCaseNil(ctx context.Context) (*VOkCaseNil, error) {
   437  	panic("not implemented")
   438  }
   439  
   440  // ValidType is the resolver for the validType field.
   441  func (r *queryResolver) ValidType(ctx context.Context) (*ValidType, error) {
   442  	panic("not implemented")
   443  }
   444  
   445  // VariadicModel is the resolver for the variadicModel field.
   446  func (r *queryResolver) VariadicModel(ctx context.Context) (*VariadicModel, error) {
   447  	panic("not implemented")
   448  }
   449  
   450  // WrappedStruct is the resolver for the wrappedStruct field.
   451  func (r *queryResolver) WrappedStruct(ctx context.Context) (*WrappedStruct, error) {
   452  	panic("not implemented")
   453  }
   454  
   455  // WrappedScalar is the resolver for the wrappedScalar field.
   456  func (r *queryResolver) WrappedScalar(ctx context.Context) (otherpkg.Scalar, error) {
   457  	panic("not implemented")
   458  }
   459  
   460  // WrappedMap is the resolver for the wrappedMap field.
   461  func (r *queryResolver) WrappedMap(ctx context.Context) (WrappedMap, error) {
   462  	panic("not implemented")
   463  }
   464  
   465  // WrappedSlice is the resolver for the wrappedSlice field.
   466  func (r *queryResolver) WrappedSlice(ctx context.Context) (WrappedSlice, error) {
   467  	panic("not implemented")
   468  }
   469  
   470  // Updated is the resolver for the updated field.
   471  func (r *subscriptionResolver) Updated(ctx context.Context) (<-chan string, error) {
   472  	panic("not implemented")
   473  }
   474  
   475  // InitPayload is the resolver for the initPayload field.
   476  func (r *subscriptionResolver) InitPayload(ctx context.Context) (<-chan string, error) {
   477  	panic("not implemented")
   478  }
   479  
   480  // DirectiveArg is the resolver for the directiveArg field.
   481  func (r *subscriptionResolver) DirectiveArg(ctx context.Context, arg string) (<-chan *string, error) {
   482  	panic("not implemented")
   483  }
   484  
   485  // DirectiveNullableArg is the resolver for the directiveNullableArg field.
   486  func (r *subscriptionResolver) DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (<-chan *string, error) {
   487  	panic("not implemented")
   488  }
   489  
   490  // DirectiveDouble is the resolver for the directiveDouble field.
   491  func (r *subscriptionResolver) DirectiveDouble(ctx context.Context) (<-chan *string, error) {
   492  	panic("not implemented")
   493  }
   494  
   495  // DirectiveUnimplemented is the resolver for the directiveUnimplemented field.
   496  func (r *subscriptionResolver) DirectiveUnimplemented(ctx context.Context) (<-chan *string, error) {
   497  	panic("not implemented")
   498  }
   499  
   500  // Issue896b is the resolver for the issue896b field.
   501  func (r *subscriptionResolver) Issue896b(ctx context.Context) (<-chan []*CheckIssue896, error) {
   502  	panic("not implemented")
   503  }
   504  
   505  // ErrorRequired is the resolver for the errorRequired field.
   506  func (r *subscriptionResolver) ErrorRequired(ctx context.Context) (<-chan *Error, error) {
   507  	panic("not implemented")
   508  }
   509  
   510  // Friends is the resolver for the friends field.
   511  func (r *userResolver) Friends(ctx context.Context, obj *User) ([]*User, error) {
   512  	panic("not implemented")
   513  }
   514  
   515  // Pets is the resolver for the pets field.
   516  func (r *userResolver) Pets(ctx context.Context, obj *User, limit *int) ([]*Pet, error) {
   517  	panic("not implemented")
   518  }
   519  
   520  // Get is the resolver for the get field.
   521  func (r *wrappedMapResolver) Get(ctx context.Context, obj WrappedMap, key string) (string, error) {
   522  	panic("not implemented")
   523  }
   524  
   525  // Get is the resolver for the get field.
   526  func (r *wrappedSliceResolver) Get(ctx context.Context, obj WrappedSlice, idx int) (string, error) {
   527  	panic("not implemented")
   528  }
   529  
   530  // BackedByInterface returns BackedByInterfaceResolver implementation.
   531  func (r *Resolver) BackedByInterface() BackedByInterfaceResolver {
   532  	return &backedByInterfaceResolver{r}
   533  }
   534  
   535  // DeferModel returns DeferModelResolver implementation.
   536  func (r *Resolver) DeferModel() DeferModelResolver { return &deferModelResolver{r} }
   537  
   538  // Errors returns ErrorsResolver implementation.
   539  func (r *Resolver) Errors() ErrorsResolver { return &errorsResolver{r} }
   540  
   541  // ForcedResolver returns ForcedResolverResolver implementation.
   542  func (r *Resolver) ForcedResolver() ForcedResolverResolver { return &forcedResolverResolver{r} }
   543  
   544  // ModelMethods returns ModelMethodsResolver implementation.
   545  func (r *Resolver) ModelMethods() ModelMethodsResolver { return &modelMethodsResolver{r} }
   546  
   547  // Mutation returns MutationResolver implementation.
   548  func (r *Resolver) Mutation() MutationResolver { return &mutationResolver{r} }
   549  
   550  // OverlappingFields returns OverlappingFieldsResolver implementation.
   551  func (r *Resolver) OverlappingFields() OverlappingFieldsResolver {
   552  	return &overlappingFieldsResolver{r}
   553  }
   554  
   555  // Panics returns PanicsResolver implementation.
   556  func (r *Resolver) Panics() PanicsResolver { return &panicsResolver{r} }
   557  
   558  // Pet returns PetResolver implementation.
   559  func (r *Resolver) Pet() PetResolver { return &petResolver{r} }
   560  
   561  // Primitive returns PrimitiveResolver implementation.
   562  func (r *Resolver) Primitive() PrimitiveResolver { return &primitiveResolver{r} }
   563  
   564  // PrimitiveString returns PrimitiveStringResolver implementation.
   565  func (r *Resolver) PrimitiveString() PrimitiveStringResolver { return &primitiveStringResolver{r} }
   566  
   567  // Query returns QueryResolver implementation.
   568  func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }
   569  
   570  // Subscription returns SubscriptionResolver implementation.
   571  func (r *Resolver) Subscription() SubscriptionResolver { return &subscriptionResolver{r} }
   572  
   573  // User returns UserResolver implementation.
   574  func (r *Resolver) User() UserResolver { return &userResolver{r} }
   575  
   576  // WrappedMap returns WrappedMapResolver implementation.
   577  func (r *Resolver) WrappedMap() WrappedMapResolver { return &wrappedMapResolver{r} }
   578  
   579  // WrappedSlice returns WrappedSliceResolver implementation.
   580  func (r *Resolver) WrappedSlice() WrappedSliceResolver { return &wrappedSliceResolver{r} }
   581  
   582  type backedByInterfaceResolver struct{ *Resolver }
   583  type deferModelResolver struct{ *Resolver }
   584  type errorsResolver struct{ *Resolver }
   585  type forcedResolverResolver struct{ *Resolver }
   586  type modelMethodsResolver struct{ *Resolver }
   587  type mutationResolver struct{ *Resolver }
   588  type overlappingFieldsResolver struct{ *Resolver }
   589  type panicsResolver struct{ *Resolver }
   590  type petResolver struct{ *Resolver }
   591  type primitiveResolver struct{ *Resolver }
   592  type primitiveStringResolver struct{ *Resolver }
   593  type queryResolver struct{ *Resolver }
   594  type subscriptionResolver struct{ *Resolver }
   595  type userResolver struct{ *Resolver }
   596  type wrappedMapResolver struct{ *Resolver }
   597  type wrappedSliceResolver struct{ *Resolver }
   598
View as plain text