github.com/sacloud/libsacloud/v2@v2.32.3/internal/define/models.go (about)

     1  // Copyright 2016-2022 The Libsacloud Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package define
    16  
    17  import (
    18  	"github.com/sacloud/libsacloud/v2/internal/dsl"
    19  	"github.com/sacloud/libsacloud/v2/internal/dsl/meta"
    20  	"github.com/sacloud/libsacloud/v2/sacloud/naked"
    21  	"github.com/sacloud/libsacloud/v2/sacloud/types"
    22  )
    23  
    24  type modelsDef struct{}
    25  
    26  var models = &modelsDef{}
    27  
    28  func (m *modelsDef) ftpServerOpenParameter() *dsl.Model {
    29  	return &dsl.Model{
    30  		Name: "OpenFTPRequest",
    31  		Fields: []*dsl.FieldDesc{
    32  			fields.FTPServerChangePassword(),
    33  		},
    34  	}
    35  }
    36  
    37  func (m *modelsDef) ftpServer() *dsl.Model {
    38  	return &dsl.Model{
    39  		Name:      "FTPServer",
    40  		NakedType: meta.Static(naked.OpeningFTPServer{}),
    41  		Fields: []*dsl.FieldDesc{
    42  			fields.HostName(),
    43  			fields.IPAddress(),
    44  			fields.User(),
    45  			fields.Password(),
    46  		},
    47  	}
    48  }
    49  
    50  func (m *modelsDef) ftpServerInfo() *dsl.Model {
    51  	return &dsl.Model{
    52  		Name:      "FTPServerInfo",
    53  		NakedType: meta.Static(naked.FTPServer{}),
    54  		Fields: []*dsl.FieldDesc{
    55  			fields.HostName(),
    56  			fields.IPAddress(),
    57  		},
    58  	}
    59  }
    60  
    61  func (m *modelsDef) diskEdit() *dsl.Model {
    62  	sshKeyFields := []*dsl.FieldDesc{
    63  		{
    64  			Name: "ID",
    65  			Type: meta.TypeID,
    66  			Tags: &dsl.FieldTags{
    67  				MapConv: ",omitempty",
    68  				JSON:    ",omitempty",
    69  			},
    70  		},
    71  		{
    72  			Name: "PublicKey",
    73  			Type: meta.TypeString,
    74  			Tags: &dsl.FieldTags{
    75  				MapConv: ",omitempty",
    76  				JSON:    ",omitempty",
    77  			},
    78  		},
    79  	}
    80  
    81  	noteFields := []*dsl.FieldDesc{
    82  		{
    83  			Name: "ID",
    84  			Type: meta.TypeID,
    85  			Tags: &dsl.FieldTags{
    86  				MapConv: ",omitempty",
    87  				JSON:    ",omitempty",
    88  			},
    89  		},
    90  		{
    91  			Name: "APIKeyID",
    92  			Type: meta.TypeID,
    93  			Tags: &dsl.FieldTags{
    94  				MapConv: "APIKey.ID,omitempty",
    95  				JSON:    ",omitempty",
    96  			},
    97  		},
    98  		{
    99  			Name: "Variables",
   100  			Type: meta.Static(map[string]interface{}{}),
   101  			Tags: &dsl.FieldTags{
   102  				MapConv: ",omitempty",
   103  				JSON:    ",omitempty",
   104  			},
   105  		},
   106  	}
   107  
   108  	userSubnetFields := []*dsl.FieldDesc{
   109  		{
   110  			Name: "DefaultRoute",
   111  			Type: meta.TypeString,
   112  			Tags: &dsl.FieldTags{
   113  				MapConv: ",omitempty",
   114  				JSON:    ",omitempty",
   115  			},
   116  		},
   117  		{
   118  			Name: "NetworkMaskLen",
   119  			Type: meta.TypeInt,
   120  			Tags: &dsl.FieldTags{
   121  				MapConv: ",omitempty",
   122  				JSON:    ",omitempty",
   123  			},
   124  		},
   125  	}
   126  
   127  	return &dsl.Model{
   128  		Name:      "DiskEditRequest",
   129  		NakedType: meta.Static(naked.DiskEdit{}),
   130  		Fields: []*dsl.FieldDesc{
   131  			{
   132  				Name: "Background",
   133  				Type: meta.TypeFlag,
   134  				Tags: &dsl.FieldTags{
   135  					MapConv: ",omitempty",
   136  					JSON:    ",omitempty",
   137  				},
   138  			},
   139  			{
   140  				Name: "Password",
   141  				Type: meta.TypeString,
   142  				Tags: &dsl.FieldTags{
   143  					MapConv: ",omitempty",
   144  					JSON:    ",omitempty",
   145  				},
   146  			},
   147  			{
   148  				Name: "SSHKey",
   149  				Type: &dsl.Model{
   150  					Name:   "DiskEditSSHKey",
   151  					Fields: sshKeyFields,
   152  				},
   153  				Tags: &dsl.FieldTags{
   154  					MapConv: ",omitempty,recursive",
   155  					JSON:    ",omitempty",
   156  				},
   157  			},
   158  			{
   159  				Name: "SSHKeys",
   160  				Type: &dsl.Model{
   161  					Name:    "DiskEditSSHKey",
   162  					IsArray: true,
   163  					Fields:  sshKeyFields,
   164  				},
   165  				Tags: &dsl.FieldTags{
   166  					MapConv: "[]SSHKeys,omitempty,recursive",
   167  					JSON:    ",omitempty",
   168  				},
   169  			},
   170  			{
   171  				Name: "DisablePWAuth",
   172  				Type: meta.TypeFlag,
   173  				Tags: &dsl.FieldTags{
   174  					MapConv: ",omitempty",
   175  					JSON:    ",omitempty",
   176  				},
   177  			},
   178  			{
   179  				Name: "EnableDHCP",
   180  				Type: meta.TypeFlag,
   181  				Tags: &dsl.FieldTags{
   182  					MapConv: ",omitempty",
   183  					JSON:    ",omitempty",
   184  				},
   185  			},
   186  			{
   187  				Name: "ChangePartitionUUID",
   188  				Type: meta.TypeFlag,
   189  				Tags: &dsl.FieldTags{
   190  					MapConv: ",omitempty",
   191  					JSON:    ",omitempty",
   192  				},
   193  			},
   194  			{
   195  				Name: "HostName",
   196  				Type: meta.TypeString,
   197  				Tags: &dsl.FieldTags{
   198  					MapConv: ",omitempty",
   199  					JSON:    ",omitempty",
   200  				},
   201  			},
   202  			{
   203  				Name: "Notes",
   204  				Type: &dsl.Model{
   205  					Name:      "DiskEditNote",
   206  					NakedType: meta.Static([]*naked.DiskEditNote{}),
   207  					IsArray:   true,
   208  					Fields:    noteFields,
   209  				},
   210  				Tags: &dsl.FieldTags{
   211  					MapConv: "[]Notes,omitempty,recursive",
   212  					JSON:    ",omitempty",
   213  				},
   214  			},
   215  			{
   216  				Name: "UserIPAddress",
   217  				Type: meta.TypeString,
   218  				Tags: &dsl.FieldTags{
   219  					MapConv: ",omitempty",
   220  					JSON:    ",omitempty",
   221  				},
   222  			},
   223  			{
   224  				Name: "UserSubnet",
   225  				Type: &dsl.Model{
   226  					Name:   "DiskEditUserSubnet",
   227  					Fields: userSubnetFields,
   228  				},
   229  				Tags: &dsl.FieldTags{
   230  					MapConv: ",omitempty",
   231  					JSON:    ",omitempty",
   232  				},
   233  			},
   234  		},
   235  	}
   236  }
   237  
   238  func (m *modelsDef) interfaceModel() *dsl.Model {
   239  	return &dsl.Model{
   240  		Name:      "InterfaceView",
   241  		NakedType: meta.Static(naked.Interface{}),
   242  		IsArray:   true,
   243  		Fields: []*dsl.FieldDesc{
   244  			fields.ID(),
   245  			fields.MACAddress(),
   246  			fields.IPAddress(),
   247  			fields.UserIPAddress(),
   248  			fields.HostName(),
   249  			// switch
   250  			{
   251  				Name: "SwitchID",
   252  				Type: meta.TypeID,
   253  				Tags: &dsl.FieldTags{
   254  					MapConv: "Switch.ID",
   255  				},
   256  			},
   257  			{
   258  				Name: "SwitchName",
   259  				Type: meta.TypeString,
   260  				Tags: &dsl.FieldTags{
   261  					MapConv: "Switch.Name",
   262  				},
   263  			},
   264  			{
   265  				Name: "SwitchScope",
   266  				Type: meta.TypeScope,
   267  				Tags: &dsl.FieldTags{
   268  					MapConv: "Switch.Scope",
   269  				},
   270  			},
   271  			{
   272  				Name: "UserSubnetDefaultRoute",
   273  				Type: meta.TypeString,
   274  				Tags: &dsl.FieldTags{
   275  					MapConv: "Switch.UserSubnet.DefaultRoute",
   276  				},
   277  			},
   278  			{
   279  				Name: "UserSubnetNetworkMaskLen",
   280  				Type: meta.TypeInt,
   281  				Tags: &dsl.FieldTags{
   282  					MapConv: "Switch.UserSubnet.NetworkMaskLen",
   283  				},
   284  			},
   285  			{
   286  				Name: "SubnetDefaultRoute",
   287  				Type: meta.TypeString,
   288  				Tags: &dsl.FieldTags{
   289  					MapConv: "Switch.Subnet.DefaultRoute",
   290  				},
   291  			},
   292  			{
   293  				Name: "SubnetNetworkMaskLen",
   294  				Type: meta.TypeInt,
   295  				Tags: &dsl.FieldTags{
   296  					MapConv: "Switch.Subnet.NetworkMaskLen",
   297  				},
   298  			},
   299  			{
   300  				Name: "SubnetNetworkAddress",
   301  				Type: meta.TypeString,
   302  				Tags: &dsl.FieldTags{
   303  					MapConv: "Switch.Subnet.NetworkAddress",
   304  				},
   305  			},
   306  			{
   307  				Name: "SubnetBandWidthMbps",
   308  				Type: meta.TypeInt,
   309  				Tags: &dsl.FieldTags{
   310  					MapConv: "Switch.Subnet.Internet.BandWidthMbps",
   311  				},
   312  			},
   313  			// packet filter
   314  			{
   315  				Name: "PacketFilterID",
   316  				Type: meta.TypeID,
   317  				Tags: &dsl.FieldTags{
   318  					MapConv: "PacketFilter.ID",
   319  				},
   320  			},
   321  			{
   322  				Name: "PacketFilterName",
   323  				Type: meta.TypeString,
   324  				Tags: &dsl.FieldTags{
   325  					MapConv: "PacketFilter.Name",
   326  				},
   327  			},
   328  			{
   329  				Name: "PacketFilterRequiredHostVersion",
   330  				Type: meta.TypeStringNumber,
   331  				Tags: &dsl.FieldTags{
   332  					MapConv: "PacketFilter.RequiredHostVersionn",
   333  				},
   334  			},
   335  			{
   336  				Name: "UpstreamType",
   337  				Type: meta.Static(types.EUpstreamNetworkType("")),
   338  			},
   339  		},
   340  	}
   341  }
   342  
   343  func (m *modelsDef) vpcRouterInterfaceModel() *dsl.Model {
   344  	ifModel := m.interfaceModel()
   345  	ifModel.Name = "VPCRouterInterface"
   346  	ifModel.Fields = append(ifModel.Fields, &dsl.FieldDesc{
   347  		Name: "Index",
   348  		Type: meta.TypeInt,
   349  		Tags: &dsl.FieldTags{
   350  			MapConv: ",omitempty",
   351  		},
   352  	})
   353  	return ifModel
   354  }
   355  
   356  func (m *modelsDef) mobileGatewayInterfaceModel() *dsl.Model {
   357  	ifModel := m.interfaceModel()
   358  	ifModel.Name = "MobileGatewayInterface"
   359  	ifModel.Fields = append(ifModel.Fields, &dsl.FieldDesc{
   360  		Name: "Index",
   361  		Type: meta.TypeInt,
   362  		Tags: &dsl.FieldTags{
   363  			MapConv: ",omitempty",
   364  		},
   365  	})
   366  	return ifModel
   367  }
   368  
   369  func (m *modelsDef) bundleInfoModel() *dsl.Model {
   370  	return &dsl.Model{
   371  		Name:      "BundleInfo",
   372  		NakedType: meta.Static(naked.BundleInfo{}),
   373  		Fields: []*dsl.FieldDesc{
   374  			fields.ID(),
   375  			{
   376  				Name: "HostClass",
   377  				Type: meta.TypeString,
   378  				Tags: &dsl.FieldTags{
   379  					MapConv: ",omitempty",
   380  					JSON:    ",omitempty",
   381  				},
   382  			},
   383  			{
   384  				Name: "ServiceClass",
   385  				Type: meta.TypeString,
   386  				Tags: &dsl.FieldTags{
   387  					MapConv: ",omitempty",
   388  					JSON:    ",omitempty",
   389  				},
   390  			},
   391  		},
   392  	}
   393  }
   394  
   395  func (m *modelsDef) storageModel() *dsl.Model {
   396  	return &dsl.Model{
   397  		Name:      "Storage",
   398  		NakedType: meta.Static(naked.Storage{}),
   399  		Fields: []*dsl.FieldDesc{
   400  			fields.ID(),
   401  			fields.Name(),
   402  			{
   403  				Name: "Class",
   404  				Type: meta.TypeString,
   405  				Tags: &dsl.FieldTags{
   406  					MapConv: ",omitempty",
   407  					JSON:    ",omitempty",
   408  				},
   409  			},
   410  			{
   411  				Name: "Generation",
   412  				Type: meta.TypeInt,
   413  				Tags: &dsl.FieldTags{
   414  					MapConv: ",omitempty",
   415  					JSON:    ",omitempty",
   416  				},
   417  			},
   418  		},
   419  	}
   420  }
   421  
   422  func (m *modelsDef) region() *dsl.Model {
   423  	return &dsl.Model{
   424  		Name:      "Region",
   425  		NakedType: meta.Static(naked.Region{}),
   426  		Fields: []*dsl.FieldDesc{
   427  			fields.ID(),
   428  			fields.Name(),
   429  			fields.Description(),
   430  			fields.NameServers(),
   431  		},
   432  	}
   433  }
   434  
   435  func (m *modelsDef) zoneInfoModel() *dsl.Model {
   436  	return &dsl.Model{
   437  		Name:      "ZoneInfo",
   438  		NakedType: meta.Static(naked.Zone{}),
   439  		Fields: []*dsl.FieldDesc{
   440  			fields.ID(),
   441  			fields.Name(),
   442  			{
   443  				Name: "DisplayName",
   444  				Type: meta.TypeString,
   445  				Tags: &dsl.FieldTags{
   446  					MapConv: "Description,omitempty",
   447  					JSON:    ",omitempty",
   448  				},
   449  			},
   450  			{
   451  				Name: "IsDummy",
   452  				Type: meta.TypeFlag,
   453  				Tags: &dsl.FieldTags{
   454  					MapConv: ",omitempty",
   455  					JSON:    ",omitempty",
   456  				},
   457  			},
   458  			{
   459  				Name: "VNCProxy",
   460  				Type: m.vncProxyModel(),
   461  				Tags: &dsl.FieldTags{
   462  					MapConv: ",omitempty,recursive",
   463  					JSON:    ",omitempty",
   464  				},
   465  			},
   466  			{
   467  				Name: "FTPServer",
   468  				Type: m.ftpServerInfo(),
   469  				Tags: &dsl.FieldTags{
   470  					MapConv: ",omitempty,recursive",
   471  					JSON:    ",omitempty",
   472  				},
   473  			},
   474  			{
   475  				Name: "Region",
   476  				Type: m.region(),
   477  				Tags: &dsl.FieldTags{
   478  					MapConv: ",omitempty,recursive",
   479  					JSON:    ",omitempty",
   480  				},
   481  			},
   482  		},
   483  	}
   484  }
   485  
   486  func (m *modelsDef) vncProxyModel() *dsl.Model {
   487  	return &dsl.Model{
   488  		Name:      "VNCProxy",
   489  		NakedType: meta.Static(naked.VNCProxy{}),
   490  		Fields: []*dsl.FieldDesc{
   491  			{
   492  				Name: "HostName",
   493  				Type: meta.TypeString,
   494  				Tags: &dsl.FieldTags{
   495  					MapConv: ",omitempty",
   496  					JSON:    ",omitempty",
   497  				},
   498  			},
   499  			{
   500  				Name: "IPAddress",
   501  				Type: meta.TypeString,
   502  				Tags: &dsl.FieldTags{
   503  					MapConv: ",omitempty",
   504  					JSON:    ",omitempty",
   505  				},
   506  			},
   507  		},
   508  	}
   509  }
   510  
   511  func (m *modelsDef) serverBootVariables() *dsl.Model {
   512  	return &dsl.Model{
   513  		Name:      "ServerBootVariables",
   514  		NakedType: meta.Static(naked.ServerBootParameter{}),
   515  		Fields: []*dsl.FieldDesc{
   516  			{
   517  				Name: "UserData",
   518  				Type: meta.TypeString,
   519  				Tags: &dsl.FieldTags{
   520  					MapConv: "CloudInit.UserData,omitempty",
   521  					JSON:    ",omitempty",
   522  				},
   523  			},
   524  		},
   525  	}
   526  }
   527  
   528  func (m *modelsDef) sourceArchiveInfo() *dsl.Model {
   529  	return &dsl.Model{
   530  		Name: "SourceArchiveInfo",
   531  		Fields: []*dsl.FieldDesc{
   532  			{
   533  				Name: "ID",
   534  				Type: meta.TypeID,
   535  				Tags: &dsl.FieldTags{
   536  					MapConv: "ArchiveUnderZone.ID",
   537  				},
   538  			},
   539  			{
   540  				Name: "AccountID",
   541  				Type: meta.TypeID,
   542  				Tags: &dsl.FieldTags{
   543  					MapConv: "ArchiveUnderZone.Account.ID",
   544  				},
   545  			},
   546  			{
   547  				Name: "ZoneID",
   548  				Type: meta.TypeID,
   549  				Tags: &dsl.FieldTags{
   550  					MapConv: "ArchiveUnderZone.Zone.ID",
   551  				},
   552  			},
   553  			{
   554  				Name: "ZoneName",
   555  				Type: meta.TypeString,
   556  				Tags: &dsl.FieldTags{
   557  					MapConv: "ArchiveUnderZone.Zone.Name",
   558  				},
   559  			},
   560  		},
   561  	}
   562  }
   563  
   564  func (m *modelsDef) packetFilterExpressions() *dsl.Model {
   565  	return &dsl.Model{
   566  		Name:      "PacketFilterExpression",
   567  		NakedType: meta.Static(naked.PacketFilterExpression{}),
   568  		IsArray:   true,
   569  		Fields: []*dsl.FieldDesc{
   570  			{
   571  				Name: "Protocol",
   572  				Type: meta.TypeProtocol,
   573  			},
   574  			{
   575  				Name: "SourceNetwork",
   576  				Type: meta.TypePacketFilterNetwork,
   577  			},
   578  			{
   579  				Name: "SourcePort",
   580  				Type: meta.TypePacketFilterPort,
   581  			},
   582  			{
   583  				Name: "DestinationPort",
   584  				Type: meta.TypePacketFilterPort,
   585  			},
   586  			{
   587  				Name: "Action",
   588  				Type: meta.TypeAction,
   589  			},
   590  			{
   591  				Name: "Description",
   592  				Type: meta.TypeString,
   593  			},
   594  		},
   595  	}
   596  }
   597  func (m *modelsDef) bridgeInfoModel() *dsl.Model {
   598  	return &dsl.Model{
   599  		Name:      "BridgeInfo",
   600  		IsArray:   true,
   601  		NakedType: meta.Static(naked.Switch{}),
   602  		Fields: []*dsl.FieldDesc{
   603  			fields.ID(),
   604  			fields.Name(),
   605  			fields.ZoneID(),
   606  			fields.ZoneName(),
   607  		},
   608  	}
   609  }
   610  
   611  func (m *modelsDef) switchInZoneModel() *dsl.Model {
   612  	return &dsl.Model{
   613  		Name:      "BridgeSwitchInfo",
   614  		NakedType: meta.Static(naked.BridgeSwitchInfo{}),
   615  		Fields: []*dsl.FieldDesc{
   616  			fields.ID(),
   617  			fields.Name(),
   618  			fields.Scope(),
   619  			{
   620  				Name: "ServerCount",
   621  				Type: meta.TypeInt,
   622  			},
   623  			{
   624  				Name: "ApplianceCount",
   625  				Type: meta.TypeInt,
   626  			},
   627  		},
   628  	}
   629  }
   630  
   631  func (m *modelsDef) internetModel() *dsl.Model {
   632  	return &dsl.Model{
   633  		Name:      "Internet",
   634  		NakedType: meta.Static(naked.Internet{}),
   635  		Fields: []*dsl.FieldDesc{
   636  			fields.ID(),
   637  			fields.Name(),
   638  			fields.Description(),
   639  			fields.Tags(),
   640  			fields.IconID(),
   641  			fields.CreatedAt(),
   642  			fields.BandWidthMbps(),
   643  			fields.NetworkMaskLen(),
   644  			{
   645  				Name: "Switch",
   646  				Type: m.switchInfoModel(),
   647  				Tags: &dsl.FieldTags{
   648  					MapConv: ",recursive",
   649  				},
   650  			},
   651  		},
   652  	}
   653  }
   654  
   655  // switchIPv6NetModel InternetリソースのフィールドとしてのIPv6Net
   656  func (m *modelsDef) switchIPv6NetModel() *dsl.Model {
   657  	return &dsl.Model{
   658  		Name:      "IPv6NetInfo",
   659  		NakedType: meta.Static(naked.IPv6Net{}),
   660  		IsArray:   false,
   661  		Fields: []*dsl.FieldDesc{
   662  			fields.ID(),
   663  			fields.Def("IPv6Prefix", meta.TypeString),
   664  			fields.Def("IPv6PrefixLen", meta.TypeInt),
   665  		},
   666  	}
   667  }
   668  
   669  // switchIPv6NetsModel InternetリソースのフィールドとしてのIPv6Net
   670  func (m *modelsDef) switchIPv6NetsModel() *dsl.Model {
   671  	return &dsl.Model{
   672  		Name:      "IPv6NetInfo",
   673  		NakedType: meta.Static(naked.IPv6Net{}),
   674  		IsArray:   true,
   675  		Fields: []*dsl.FieldDesc{
   676  			fields.ID(),
   677  			fields.Def("IPv6Prefix", meta.TypeString),
   678  			fields.Def("IPv6PrefixLen", meta.TypeInt),
   679  		},
   680  	}
   681  }
   682  
   683  // switchInfoModel Internetリソースのフィールドとしてのswitch
   684  //
   685  // Subnetの情報は限定的にしか返ってこない(IPAddresses.Max/Minなどがない)ため注意
   686  // 必要であればSwitchリソース配下のSubnetsを参照すればOK
   687  func (m *modelsDef) switchInfoModel() *dsl.Model {
   688  	return &dsl.Model{
   689  		Name:      "SwitchInfo",
   690  		NakedType: meta.Static(naked.Switch{}),
   691  		Fields: []*dsl.FieldDesc{
   692  			fields.ID(),
   693  			fields.Name(),
   694  			fields.Description(),
   695  			fields.Tags(),
   696  			fields.Scope(),
   697  			{
   698  				Name: "Subnets",
   699  				Type: m.internetSubnet(),
   700  				Tags: &dsl.FieldTags{
   701  					MapConv: "[]Subnets,recursive",
   702  				},
   703  			},
   704  			fields.Def("IPv6Nets", m.switchIPv6NetsModel(), mapConvTag("[]IPv6Nets,recursive,omitempty")),
   705  		},
   706  	}
   707  }
   708  
   709  func (m *modelsDef) internetSubnet() *dsl.Model {
   710  	return &dsl.Model{
   711  		Name:      "InternetSubnet",
   712  		NakedType: meta.Static(naked.Subnet{}),
   713  		IsArray:   true,
   714  		Fields: []*dsl.FieldDesc{
   715  			fields.ID(),
   716  			fields.DefaultRoute(),
   717  			fields.NextHop(),
   718  			fields.StaticRoute(),
   719  			fields.NetworkAddress(),
   720  			fields.NetworkMaskLen(),
   721  		},
   722  	}
   723  }
   724  
   725  // internetSubnetOperationResult Internetリソースへのサブネット追加/更新時の戻り値
   726  //
   727  // internetSubnetに対しIPAddresses(文字列配列)を追加したもの
   728  func (m *modelsDef) internetSubnetOperationResult() *dsl.Model {
   729  	return &dsl.Model{
   730  		Name:      "InternetSubnetOperationResult",
   731  		NakedType: meta.Static(naked.Subnet{}),
   732  		Fields: []*dsl.FieldDesc{
   733  			fields.ID(),
   734  			fields.DefaultRoute(),
   735  			fields.NextHop(),
   736  			fields.StaticRoute(),
   737  			fields.NetworkAddress(),
   738  			fields.NetworkMaskLen(),
   739  			{
   740  				Name: "IPAddresses",
   741  				Type: meta.TypeStringSlice,
   742  				Tags: &dsl.FieldTags{
   743  					MapConv: "[]IPAddresses.IPAddress",
   744  				},
   745  			},
   746  		},
   747  	}
   748  }
   749  
   750  func (m *modelsDef) switchSubnet() *dsl.Model {
   751  	// switchSubnetはinternetSubnetにInternetとIPAddressesを追加したもの
   752  	subnet := m.internetSubnet()
   753  	subnet.Name = "SwitchSubnet"
   754  	subnet.Fields = append(subnet.Fields,
   755  		&dsl.FieldDesc{
   756  			Name: "Internet",
   757  			Type: m.internetModel(),
   758  		},
   759  		&dsl.FieldDesc{
   760  			Name: "AssignedIPAddressMax",
   761  			Type: meta.TypeString,
   762  			Tags: &dsl.FieldTags{
   763  				MapConv: "IPAddresses.Max",
   764  			},
   765  		},
   766  		&dsl.FieldDesc{
   767  			Name: "AssignedIPAddressMin",
   768  			Type: meta.TypeString,
   769  			Tags: &dsl.FieldTags{
   770  				MapConv: "IPAddresses.Min",
   771  			},
   772  		},
   773  	)
   774  	subnet.Methods = []*dsl.MethodDesc{
   775  		{
   776  			Name:        "GetAssignedIPAddresses",
   777  			Description: "割り当てられたIPアドレスのリスト",
   778  			ResultTypes: []meta.Type{meta.TypeStringSlice},
   779  		},
   780  	}
   781  	return subnet
   782  }
   783  
   784  //******************************************************************************
   785  // VPCRouter
   786  //******************************************************************************
   787  
   788  func (m *modelsDef) vpcRouterSetting() *dsl.Model {
   789  	return &dsl.Model{
   790  		Name:      "VPCRouterSetting",
   791  		NakedType: meta.Static(naked.VPCRouterSettings{}),
   792  		Fields: []*dsl.FieldDesc{
   793  			{
   794  				Name: "VRID",
   795  				Type: meta.TypeInt,
   796  				Tags: &dsl.FieldTags{
   797  					JSON:    ",omitempty",
   798  					MapConv: "Router.VRID",
   799  				},
   800  			},
   801  			{
   802  				Name: "InternetConnectionEnabled",
   803  				Type: meta.TypeStringFlag,
   804  				Tags: &dsl.FieldTags{
   805  					MapConv: "Router.InternetConnection.Enabled,omitempty",
   806  				},
   807  			},
   808  			{
   809  				Name: "Interfaces",
   810  				Type: m.vpcRouterInterface(),
   811  				Tags: &dsl.FieldTags{
   812  					MapConv: "Router.[]Interfaces,omitempty,recursive",
   813  				},
   814  			},
   815  			{
   816  				Name: "StaticNAT",
   817  				Type: m.vpcRouterStaticNAT(),
   818  				Tags: &dsl.FieldTags{
   819  					MapConv: "Router.StaticNAT.[]Config,omitempty,recursive",
   820  				},
   821  			},
   822  			{
   823  				Name: "PortForwarding",
   824  				Type: m.vpcRouterPortForwarding(),
   825  				Tags: &dsl.FieldTags{
   826  					MapConv: "Router.PortForwarding.[]Config,omitempty,recursive",
   827  				},
   828  			},
   829  			{
   830  				Name: "Firewall",
   831  				Type: m.vpcRouterFirewall(),
   832  				Tags: &dsl.FieldTags{
   833  					MapConv: "Router.Firewall.[]Config,omitempty,recursive",
   834  				},
   835  			},
   836  			{
   837  				Name: "DHCPServer",
   838  				Type: m.vpcRouterDHCPServer(),
   839  				Tags: &dsl.FieldTags{
   840  					MapConv: "Router.DHCPServer.[]Config,omitempty,recursive",
   841  				},
   842  			},
   843  			{
   844  				Name: "DHCPStaticMapping",
   845  				Type: m.vpcRouterDHCPStaticMapping(),
   846  				Tags: &dsl.FieldTags{
   847  					MapConv: "Router.DHCPStaticMapping.[]Config,omitempty,recursive",
   848  				},
   849  			},
   850  			{
   851  				Name: "DNSForwarding",
   852  				Type: m.vpcRouterDNSForwarding(),
   853  				Tags: &dsl.FieldTags{
   854  					MapConv: "Router.DNSForwarding,omitempty,recursive",
   855  				},
   856  			},
   857  			{
   858  				Name: "PPTPServer",
   859  				Type: m.vpcRouterPPTPServer(),
   860  				Tags: &dsl.FieldTags{
   861  					MapConv: "Router.PPTPServer.Config,omitempty,recursive",
   862  				},
   863  			},
   864  			{
   865  				Name: "PPTPServerEnabled",
   866  				Type: meta.TypeStringFlag,
   867  				Tags: &dsl.FieldTags{
   868  					MapConv: "Router.PPTPServer.Enabled,omitempty",
   869  				},
   870  			},
   871  			{
   872  				Name: "L2TPIPsecServer",
   873  				Type: m.vpcRouterL2TPIPsecServer(),
   874  				Tags: &dsl.FieldTags{
   875  					MapConv: "Router.L2TPIPsecServer.Config,omitempty,recursive",
   876  				},
   877  			},
   878  			{
   879  				Name: "L2TPIPsecServerEnabled",
   880  				Type: meta.TypeStringFlag,
   881  				Tags: &dsl.FieldTags{
   882  					MapConv: "Router.L2TPIPsecServer.Enabled,omitempty",
   883  				},
   884  			},
   885  			{
   886  				Name: "WireGuard",
   887  				Type: m.vpcRouterWireGuard(),
   888  				Tags: &dsl.FieldTags{
   889  					MapConv: "Router.WireGuard.Config,omitempty,recursive",
   890  				},
   891  			},
   892  			{
   893  				Name: "WireGuardEnabled",
   894  				Type: meta.TypeStringFlag,
   895  				Tags: &dsl.FieldTags{
   896  					MapConv: "Router.WireGuard.Enabled,omitempty",
   897  				},
   898  			},
   899  			{
   900  				Name: "RemoteAccessUsers",
   901  				Type: m.vpcRouterRemoteAccessUser(),
   902  				Tags: &dsl.FieldTags{
   903  					MapConv: "Router.RemoteAccessUsers.[]Config,omitempty,recursive",
   904  				},
   905  			},
   906  			{
   907  				Name: "SiteToSiteIPsecVPN",
   908  				Type: m.vpcRouterSiteToSiteIPsecVPN(),
   909  				Tags: &dsl.FieldTags{
   910  					MapConv: "Router.SiteToSiteIPsecVPN.[]Config,omitempty,recursive",
   911  				},
   912  			},
   913  			{
   914  				Name: "StaticRoute",
   915  				Type: m.vpcRouterStaticRoute(),
   916  				Tags: &dsl.FieldTags{
   917  					MapConv: "Router.StaticRoutes.[]Config,omitempty,recursive",
   918  				},
   919  			},
   920  			{
   921  				Name: "SyslogHost",
   922  				Type: meta.TypeString,
   923  				Tags: &dsl.FieldTags{
   924  					MapConv: "Router.SyslogHost",
   925  				},
   926  			},
   927  		},
   928  	}
   929  }
   930  
   931  func (m *modelsDef) vpcRouterInterface() *dsl.Model {
   932  	return &dsl.Model{
   933  		Name:      "VPCRouterInterfaceSetting",
   934  		NakedType: meta.Static(naked.VPCRouterInterface{}),
   935  		IsArray:   true,
   936  		Fields: []*dsl.FieldDesc{
   937  			{
   938  				Name: "IPAddress",
   939  				Type: meta.TypeStringSlice,
   940  			},
   941  			{
   942  				Name: "VirtualIPAddress",
   943  				Type: meta.TypeString,
   944  			},
   945  			{
   946  				Name: "IPAliases",
   947  				Type: meta.TypeStringSlice,
   948  			},
   949  			{
   950  				Name: "NetworkMaskLen",
   951  				Type: meta.TypeInt,
   952  			},
   953  			{
   954  				Name: "Index",
   955  				Type: meta.TypeInt,
   956  			},
   957  		},
   958  	}
   959  }
   960  
   961  func (m *modelsDef) vpcRouterStaticNAT() *dsl.Model {
   962  	return &dsl.Model{
   963  		Name:      "VPCRouterStaticNAT",
   964  		NakedType: meta.Static(naked.VPCRouterStaticNATConfig{}),
   965  		IsArray:   true,
   966  		Fields: []*dsl.FieldDesc{
   967  			{
   968  				Name: "GlobalAddress",
   969  				Type: meta.TypeString,
   970  				Tags: &dsl.FieldTags{
   971  					MapConv: "GlobalAddress",
   972  				},
   973  			},
   974  			{
   975  				Name: "PrivateAddress",
   976  				Type: meta.TypeString,
   977  				Tags: &dsl.FieldTags{
   978  					MapConv: "PrivateAddress",
   979  				},
   980  			},
   981  			{
   982  				Name: "Description",
   983  				Type: meta.TypeString,
   984  			},
   985  		},
   986  	}
   987  }
   988  
   989  func (m *modelsDef) vpcRouterPortForwarding() *dsl.Model {
   990  	return &dsl.Model{
   991  		Name:      "VPCRouterPortForwarding",
   992  		NakedType: meta.Static(naked.VPCRouterPortForwardingConfig{}),
   993  		IsArray:   true,
   994  		Fields: []*dsl.FieldDesc{
   995  			{
   996  				Name: "Protocol",
   997  				Type: meta.Static(types.EVPCRouterPortForwardingProtocol("")),
   998  			},
   999  			{
  1000  				Name: "GlobalPort",
  1001  				Type: meta.TypeStringNumber,
  1002  			},
  1003  			{
  1004  				Name: "PrivateAddress",
  1005  				Type: meta.TypeString,
  1006  				Tags: &dsl.FieldTags{
  1007  					MapConv: "PrivateAddress",
  1008  				},
  1009  			},
  1010  			{
  1011  				Name: "PrivatePort",
  1012  				Type: meta.TypeStringNumber,
  1013  			},
  1014  			{
  1015  				Name: "Description",
  1016  				Type: meta.TypeString,
  1017  			},
  1018  		},
  1019  	}
  1020  }
  1021  
  1022  func (m *modelsDef) vpcRouterFirewall() *dsl.Model {
  1023  	return &dsl.Model{
  1024  		Name:      "VPCRouterFirewall",
  1025  		NakedType: meta.Static(naked.VPCRouterFirewallConfig{}),
  1026  		IsArray:   true,
  1027  		Fields: []*dsl.FieldDesc{
  1028  			{
  1029  				Name: "Send",
  1030  				Type: m.vpcRouterFirewallRule(),
  1031  			},
  1032  			{
  1033  				Name: "Receive",
  1034  				Type: m.vpcRouterFirewallRule(),
  1035  			},
  1036  			{
  1037  				Name: "Index",
  1038  				Type: meta.TypeInt,
  1039  			},
  1040  		},
  1041  	}
  1042  }
  1043  func (m *modelsDef) vpcRouterFirewallRule() *dsl.Model {
  1044  	return &dsl.Model{
  1045  		Name:      "VPCRouterFirewallRule",
  1046  		NakedType: meta.Static(naked.VPCRouterFirewallRule{}),
  1047  		IsArray:   true,
  1048  		Fields: []*dsl.FieldDesc{
  1049  			{
  1050  				Name: "Protocol",
  1051  				Type: meta.TypeProtocol,
  1052  			},
  1053  			{
  1054  				Name: "SourceNetwork",
  1055  				Type: meta.TypeVPCFirewallNetwork,
  1056  			},
  1057  			{
  1058  				Name: "SourcePort",
  1059  				Type: meta.TypeVPCFirewallPort,
  1060  			},
  1061  			{
  1062  				Name: "DestinationNetwork",
  1063  				Type: meta.TypeVPCFirewallNetwork,
  1064  			},
  1065  			{
  1066  				Name: "DestinationPort",
  1067  				Type: meta.TypeVPCFirewallPort,
  1068  			},
  1069  			{
  1070  				Name: "Action",
  1071  				Type: meta.TypeAction,
  1072  			},
  1073  			{
  1074  				Name: "Logging",
  1075  				Type: meta.TypeStringFlag,
  1076  			},
  1077  			{
  1078  				Name: "Description",
  1079  				Type: meta.TypeString,
  1080  			},
  1081  		},
  1082  	}
  1083  }
  1084  
  1085  func (m *modelsDef) vpcRouterDHCPServer() *dsl.Model {
  1086  	return &dsl.Model{
  1087  		Name:      "VPCRouterDHCPServer",
  1088  		NakedType: meta.Static(naked.VPCRouterDHCPServerConfig{}),
  1089  		IsArray:   true,
  1090  		Fields: []*dsl.FieldDesc{
  1091  			{
  1092  				Name: "Interface",
  1093  				Type: meta.TypeString,
  1094  			},
  1095  			{
  1096  				Name: "RangeStart",
  1097  				Type: meta.TypeString,
  1098  			},
  1099  			{
  1100  				Name: "RangeStop",
  1101  				Type: meta.TypeString,
  1102  			},
  1103  			{
  1104  				Name: "DNSServers",
  1105  				Type: meta.TypeStringSlice,
  1106  			},
  1107  		},
  1108  	}
  1109  }
  1110  
  1111  func (m *modelsDef) vpcRouterDHCPStaticMapping() *dsl.Model {
  1112  	return &dsl.Model{
  1113  		Name:      "VPCRouterDHCPStaticMapping",
  1114  		NakedType: meta.Static(naked.VPCRouterDHCPStaticMappingConfig{}),
  1115  		IsArray:   true,
  1116  		Fields: []*dsl.FieldDesc{
  1117  			{
  1118  				Name: "MACAddress",
  1119  				Type: meta.TypeString,
  1120  			},
  1121  			{
  1122  				Name: "IPAddress",
  1123  				Type: meta.TypeString,
  1124  			},
  1125  		},
  1126  	}
  1127  }
  1128  
  1129  func (m *modelsDef) vpcRouterDNSForwarding() *dsl.Model {
  1130  	return &dsl.Model{
  1131  		Name:      "VPCRouterDNSForwarding",
  1132  		NakedType: meta.Static(naked.VPCRouterDNSForwarding{}),
  1133  		Fields: []*dsl.FieldDesc{
  1134  			{
  1135  				Name: "Interface",
  1136  				Type: meta.TypeString,
  1137  			},
  1138  			{
  1139  				Name: "DNSServers",
  1140  				Type: meta.TypeStringSlice,
  1141  			},
  1142  		},
  1143  	}
  1144  }
  1145  
  1146  func (m *modelsDef) vpcRouterPPTPServer() *dsl.Model {
  1147  	return &dsl.Model{
  1148  		Name:      "VPCRouterPPTPServer",
  1149  		NakedType: meta.Static(naked.VPCRouterPPTPServerConfig{}),
  1150  		Fields: []*dsl.FieldDesc{
  1151  			{
  1152  				Name: "RangeStart",
  1153  				Type: meta.TypeString,
  1154  			},
  1155  			{
  1156  				Name: "RangeStop",
  1157  				Type: meta.TypeString,
  1158  			},
  1159  		},
  1160  	}
  1161  }
  1162  
  1163  func (m *modelsDef) vpcRouterL2TPIPsecServer() *dsl.Model {
  1164  	return &dsl.Model{
  1165  		Name:      "VPCRouterL2TPIPsecServer",
  1166  		NakedType: meta.Static(naked.VPCRouterL2TPIPsecServerConfig{}),
  1167  		Fields: []*dsl.FieldDesc{
  1168  			{
  1169  				Name: "RangeStart",
  1170  				Type: meta.TypeString,
  1171  			},
  1172  			{
  1173  				Name: "RangeStop",
  1174  				Type: meta.TypeString,
  1175  			},
  1176  			{
  1177  				Name: "PreSharedSecret",
  1178  				Type: meta.TypeString,
  1179  			},
  1180  		},
  1181  	}
  1182  }
  1183  
  1184  func (m *modelsDef) vpcRouterWireGuard() *dsl.Model {
  1185  	return &dsl.Model{
  1186  		Name:      "VPCRouterWireGuard",
  1187  		NakedType: meta.Static(naked.VPCRouterWireGuardConfig{}),
  1188  		Fields: []*dsl.FieldDesc{
  1189  			{
  1190  				Name: "IPAddress",
  1191  				Type: meta.TypeString,
  1192  			},
  1193  			{
  1194  				Name: "Peers",
  1195  				Tags: &dsl.FieldTags{
  1196  					MapConv: "[]Peers,omitempty,recursive",
  1197  				},
  1198  				Type: m.vpcRouterWireGuardPeer(),
  1199  			},
  1200  		},
  1201  	}
  1202  }
  1203  
  1204  func (m *modelsDef) vpcRouterWireGuardPeer() *dsl.Model {
  1205  	return &dsl.Model{
  1206  		Name:      "VPCRouterWireGuardPeer",
  1207  		NakedType: meta.Static(naked.VPCRouterWireGuardPeer{}),
  1208  		IsArray:   true,
  1209  		Fields: []*dsl.FieldDesc{
  1210  			{
  1211  				Name: "Name",
  1212  				Type: meta.TypeString,
  1213  			},
  1214  			{
  1215  				Name: "IPAddress",
  1216  				Type: meta.TypeString,
  1217  			},
  1218  			{
  1219  				Name: "PublicKey",
  1220  				Type: meta.TypeString,
  1221  			},
  1222  		},
  1223  	}
  1224  }
  1225  
  1226  func (m *modelsDef) vpcRouterRemoteAccessUser() *dsl.Model {
  1227  	return &dsl.Model{
  1228  		Name:      "VPCRouterRemoteAccessUser",
  1229  		NakedType: meta.Static(naked.VPCRouterRemoteAccessUserConfig{}),
  1230  		IsArray:   true,
  1231  		Fields: []*dsl.FieldDesc{
  1232  			{
  1233  				Name: "UserName",
  1234  				Type: meta.TypeString,
  1235  			},
  1236  			{
  1237  				Name: "Password",
  1238  				Type: meta.TypeString,
  1239  			},
  1240  		},
  1241  	}
  1242  }
  1243  
  1244  func (m *modelsDef) vpcRouterSiteToSiteIPsecVPN() *dsl.Model {
  1245  	return &dsl.Model{
  1246  		Name:      "VPCRouterSiteToSiteIPsecVPN",
  1247  		NakedType: meta.Static(naked.VPCRouterSiteToSiteIPsecVPNConfig{}),
  1248  		IsArray:   true,
  1249  		Fields: []*dsl.FieldDesc{
  1250  			{
  1251  				Name: "Peer",
  1252  				Type: meta.TypeString,
  1253  			},
  1254  			{
  1255  				Name: "PreSharedSecret",
  1256  				Type: meta.TypeString,
  1257  			},
  1258  			{
  1259  				Name: "RemoteID",
  1260  				Type: meta.TypeString,
  1261  			},
  1262  			{
  1263  				Name: "Routes",
  1264  				Type: meta.TypeStringSlice,
  1265  			},
  1266  			{
  1267  				Name: "LocalPrefix",
  1268  				Type: meta.TypeStringSlice,
  1269  			},
  1270  		},
  1271  	}
  1272  }
  1273  
  1274  func (m *modelsDef) vpcRouterStaticRoute() *dsl.Model {
  1275  	return &dsl.Model{
  1276  		Name:      "VPCRouterStaticRoute",
  1277  		NakedType: meta.Static(naked.VPCRouterStaticRouteConfig{}),
  1278  		IsArray:   true,
  1279  		Fields: []*dsl.FieldDesc{
  1280  			{
  1281  				Name: "Prefix",
  1282  				Type: meta.TypeString,
  1283  			},
  1284  			{
  1285  				Name: "NextHop",
  1286  				Type: meta.TypeString,
  1287  			},
  1288  		},
  1289  	}
  1290  }
  1291  
  1292  func (m *modelsDef) vpcRouterSessionAnalyticsValue() *dsl.Model {
  1293  	return &dsl.Model{
  1294  		Name:      "VPCRouterStatisticsValue",
  1295  		NakedType: meta.Static(naked.VPCRouterStatisticsValue{}),
  1296  		IsArray:   true,
  1297  		Fields: []*dsl.FieldDesc{
  1298  			{
  1299  				Name: "Name",
  1300  				Type: meta.TypeString,
  1301  			},
  1302  			{
  1303  				Name: "Count",
  1304  				Type: meta.TypeInt,
  1305  			},
  1306  		},
  1307  	}
  1308  }
  1309  
  1310  //******************************************************************************
  1311  // Mobile Gateway
  1312  //******************************************************************************
  1313  
  1314  func (m *modelsDef) mobileGatewayInterface() *dsl.Model {
  1315  	return &dsl.Model{
  1316  		Name:      "MobileGatewayInterfaceSetting",
  1317  		NakedType: meta.Static(naked.MobileGatewayInterface{}),
  1318  		IsArray:   true,
  1319  		Fields: []*dsl.FieldDesc{
  1320  			fields.Def("IPAddress", meta.TypeStringSlice),
  1321  			fields.Def("NetworkMaskLen", meta.TypeInt),
  1322  			fields.Def("Index", meta.TypeInt),
  1323  		},
  1324  	}
  1325  }
  1326  
  1327  func (m *modelsDef) mobileGatewayStaticRoute() *dsl.Model {
  1328  	return &dsl.Model{
  1329  		Name:      "MobileGatewayStaticRoute",
  1330  		NakedType: meta.Static(naked.MobileGatewayStaticRoute{}),
  1331  		IsArray:   true,
  1332  		Fields: []*dsl.FieldDesc{
  1333  			fields.Def("Prefix", meta.TypeString),
  1334  			fields.Def("NextHop", meta.TypeString),
  1335  		},
  1336  	}
  1337  }
  1338  
  1339  //******************************************************************************
  1340  // SIM
  1341  //******************************************************************************
  1342  
  1343  func (m *modelsDef) simInfo() *dsl.Model {
  1344  	return &dsl.Model{
  1345  		Name:      "SIMInfo",
  1346  		NakedType: meta.Static(naked.SIMInfo{}),
  1347  		Fields:    m.simInfoFields(),
  1348  	}
  1349  }
  1350  
  1351  func (m *modelsDef) simInfoList() *dsl.Model {
  1352  	return &dsl.Model{
  1353  		Name:      "MobileGatewaySIMInfo",
  1354  		Alias:     "MobileGatewaySIMs",
  1355  		NakedType: meta.Static(naked.SIMInfo{}),
  1356  		Fields:    m.simInfoFields(),
  1357  	}
  1358  }
  1359  
  1360  func (m *modelsDef) simInfoFields() []*dsl.FieldDesc {
  1361  	return []*dsl.FieldDesc{
  1362  		fields.Def("ICCID", meta.TypeString),
  1363  		fields.Def("IMSI", meta.TypeStringSlice),
  1364  		fields.Def("IMEI", meta.TypeString),
  1365  		fields.Def("IP", meta.TypeString),
  1366  		fields.Def("SessionStatus", meta.TypeString),
  1367  		fields.Def("IMEILock", meta.TypeFlag),
  1368  		fields.Def("Registered", meta.TypeFlag),
  1369  		fields.Def("Activated", meta.TypeFlag),
  1370  		fields.Def("ResourceID", meta.TypeString),
  1371  		fields.Def("RegisteredDate", meta.TypeTime),
  1372  		fields.Def("ActivatedDate", meta.TypeTime),
  1373  		fields.Def("DeactivatedDate", meta.TypeTime),
  1374  		fields.Def("SIMGroupID", meta.TypeString),
  1375  		{
  1376  			Name: "TrafficBytesOfCurrentMonth",
  1377  			Type: &dsl.Model{
  1378  				Name: "SIMTrafficBytes",
  1379  				Fields: []*dsl.FieldDesc{
  1380  					fields.Def("UplinkBytes", meta.TypeInt64),
  1381  					fields.Def("DownlinkBytes", meta.TypeInt64),
  1382  				},
  1383  			},
  1384  			Tags: &dsl.FieldTags{
  1385  				MapConv: ",recursive",
  1386  			},
  1387  		},
  1388  		fields.Def("ConnectedIMEI", meta.TypeString),
  1389  	}
  1390  }
  1391  
  1392  func (m *modelsDef) migrationJobStatus() *dsl.Model {
  1393  	return &dsl.Model{
  1394  		Name:      "JobStatus",
  1395  		NakedType: meta.Static(naked.MigrationJobStatus{}),
  1396  		Fields: []*dsl.FieldDesc{
  1397  			fields.Def("Status", meta.TypeString),
  1398  			fields.Def("ConfigError", &dsl.Model{
  1399  				Name:      "JobConfigError",
  1400  				NakedType: meta.Static(naked.JobConfigError{}),
  1401  				Fields: []*dsl.FieldDesc{
  1402  					fields.Def("ErrorCode", meta.TypeString),
  1403  					fields.Def("ErrorMsg", meta.TypeString),
  1404  					fields.Def("Status", meta.TypeString),
  1405  				},
  1406  			}),
  1407  		},
  1408  	}
  1409  }