github.com/sacloud/iaas-api-go@v1.12.0/internal/define/models.go (about)

     1  // Copyright 2022-2023 The sacloud/iaas-api-go 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/iaas-api-go/internal/dsl"
    19  	"github.com/sacloud/iaas-api-go/internal/dsl/meta"
    20  	"github.com/sacloud/iaas-api-go/naked"
    21  	"github.com/sacloud/iaas-api-go/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",
   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",
   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",
   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",
   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,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  				Name: "ScheduledMaintenance",
   929  				Type: m.vpcRouterScheduledMaintenance(),
   930  				Tags: &dsl.FieldTags{
   931  					MapConv: "Router.ScheduledMaintenance,omitempty,recursive",
   932  				},
   933  			},
   934  		},
   935  	}
   936  }
   937  
   938  func (m *modelsDef) vpcRouterInterface() *dsl.Model {
   939  	return &dsl.Model{
   940  		Name:      "VPCRouterInterfaceSetting",
   941  		NakedType: meta.Static(naked.VPCRouterInterface{}),
   942  		IsArray:   true,
   943  		Fields: []*dsl.FieldDesc{
   944  			{
   945  				Name: "IPAddress",
   946  				Type: meta.TypeStringSlice,
   947  			},
   948  			{
   949  				Name: "VirtualIPAddress",
   950  				Type: meta.TypeString,
   951  			},
   952  			{
   953  				Name: "IPAliases",
   954  				Type: meta.TypeStringSlice,
   955  			},
   956  			{
   957  				Name: "NetworkMaskLen",
   958  				Type: meta.TypeInt,
   959  			},
   960  			{
   961  				Name: "Index",
   962  				Type: meta.TypeInt,
   963  			},
   964  		},
   965  	}
   966  }
   967  
   968  func (m *modelsDef) vpcRouterStaticNAT() *dsl.Model {
   969  	return &dsl.Model{
   970  		Name:      "VPCRouterStaticNAT",
   971  		NakedType: meta.Static(naked.VPCRouterStaticNATConfig{}),
   972  		IsArray:   true,
   973  		Fields: []*dsl.FieldDesc{
   974  			{
   975  				Name: "GlobalAddress",
   976  				Type: meta.TypeString,
   977  				Tags: &dsl.FieldTags{
   978  					MapConv: "GlobalAddress",
   979  				},
   980  			},
   981  			{
   982  				Name: "PrivateAddress",
   983  				Type: meta.TypeString,
   984  				Tags: &dsl.FieldTags{
   985  					MapConv: "PrivateAddress",
   986  				},
   987  			},
   988  			{
   989  				Name: "Description",
   990  				Type: meta.TypeString,
   991  			},
   992  		},
   993  	}
   994  }
   995  
   996  func (m *modelsDef) vpcRouterPortForwarding() *dsl.Model {
   997  	return &dsl.Model{
   998  		Name:      "VPCRouterPortForwarding",
   999  		NakedType: meta.Static(naked.VPCRouterPortForwardingConfig{}),
  1000  		IsArray:   true,
  1001  		Fields: []*dsl.FieldDesc{
  1002  			{
  1003  				Name: "Protocol",
  1004  				Type: meta.Static(types.EVPCRouterPortForwardingProtocol("")),
  1005  			},
  1006  			{
  1007  				Name: "GlobalPort",
  1008  				Type: meta.TypeStringNumber,
  1009  			},
  1010  			{
  1011  				Name: "PrivateAddress",
  1012  				Type: meta.TypeString,
  1013  				Tags: &dsl.FieldTags{
  1014  					MapConv: "PrivateAddress",
  1015  				},
  1016  			},
  1017  			{
  1018  				Name: "PrivatePort",
  1019  				Type: meta.TypeStringNumber,
  1020  			},
  1021  			{
  1022  				Name: "Description",
  1023  				Type: meta.TypeString,
  1024  			},
  1025  		},
  1026  	}
  1027  }
  1028  
  1029  func (m *modelsDef) vpcRouterFirewall() *dsl.Model {
  1030  	return &dsl.Model{
  1031  		Name:      "VPCRouterFirewall",
  1032  		NakedType: meta.Static(naked.VPCRouterFirewallConfig{}),
  1033  		IsArray:   true,
  1034  		Fields: []*dsl.FieldDesc{
  1035  			{
  1036  				Name: "Send",
  1037  				Type: m.vpcRouterFirewallRule(),
  1038  			},
  1039  			{
  1040  				Name: "Receive",
  1041  				Type: m.vpcRouterFirewallRule(),
  1042  			},
  1043  			{
  1044  				Name: "Index",
  1045  				Type: meta.TypeInt,
  1046  			},
  1047  		},
  1048  	}
  1049  }
  1050  func (m *modelsDef) vpcRouterFirewallRule() *dsl.Model {
  1051  	return &dsl.Model{
  1052  		Name:      "VPCRouterFirewallRule",
  1053  		NakedType: meta.Static(naked.VPCRouterFirewallRule{}),
  1054  		IsArray:   true,
  1055  		Fields: []*dsl.FieldDesc{
  1056  			{
  1057  				Name: "Protocol",
  1058  				Type: meta.TypeProtocol,
  1059  			},
  1060  			{
  1061  				Name: "SourceNetwork",
  1062  				Type: meta.TypeVPCFirewallNetwork,
  1063  			},
  1064  			{
  1065  				Name: "SourcePort",
  1066  				Type: meta.TypeVPCFirewallPort,
  1067  			},
  1068  			{
  1069  				Name: "DestinationNetwork",
  1070  				Type: meta.TypeVPCFirewallNetwork,
  1071  			},
  1072  			{
  1073  				Name: "DestinationPort",
  1074  				Type: meta.TypeVPCFirewallPort,
  1075  			},
  1076  			{
  1077  				Name: "Action",
  1078  				Type: meta.TypeAction,
  1079  			},
  1080  			{
  1081  				Name: "Logging",
  1082  				Type: meta.TypeStringFlag,
  1083  			},
  1084  			{
  1085  				Name: "Description",
  1086  				Type: meta.TypeString,
  1087  			},
  1088  		},
  1089  	}
  1090  }
  1091  
  1092  func (m *modelsDef) vpcRouterDHCPServer() *dsl.Model {
  1093  	return &dsl.Model{
  1094  		Name:      "VPCRouterDHCPServer",
  1095  		NakedType: meta.Static(naked.VPCRouterDHCPServerConfig{}),
  1096  		IsArray:   true,
  1097  		Fields: []*dsl.FieldDesc{
  1098  			{
  1099  				Name: "Interface",
  1100  				Type: meta.TypeString,
  1101  			},
  1102  			{
  1103  				Name: "RangeStart",
  1104  				Type: meta.TypeString,
  1105  			},
  1106  			{
  1107  				Name: "RangeStop",
  1108  				Type: meta.TypeString,
  1109  			},
  1110  			{
  1111  				Name: "DNSServers",
  1112  				Type: meta.TypeStringSlice,
  1113  			},
  1114  		},
  1115  	}
  1116  }
  1117  
  1118  func (m *modelsDef) vpcRouterDHCPStaticMapping() *dsl.Model {
  1119  	return &dsl.Model{
  1120  		Name:      "VPCRouterDHCPStaticMapping",
  1121  		NakedType: meta.Static(naked.VPCRouterDHCPStaticMappingConfig{}),
  1122  		IsArray:   true,
  1123  		Fields: []*dsl.FieldDesc{
  1124  			{
  1125  				Name: "MACAddress",
  1126  				Type: meta.TypeString,
  1127  			},
  1128  			{
  1129  				Name: "IPAddress",
  1130  				Type: meta.TypeString,
  1131  			},
  1132  		},
  1133  	}
  1134  }
  1135  
  1136  func (m *modelsDef) vpcRouterDNSForwarding() *dsl.Model {
  1137  	return &dsl.Model{
  1138  		Name:      "VPCRouterDNSForwarding",
  1139  		NakedType: meta.Static(naked.VPCRouterDNSForwarding{}),
  1140  		Fields: []*dsl.FieldDesc{
  1141  			{
  1142  				Name: "Interface",
  1143  				Type: meta.TypeString,
  1144  			},
  1145  			{
  1146  				Name: "DNSServers",
  1147  				Type: meta.TypeStringSlice,
  1148  			},
  1149  		},
  1150  	}
  1151  }
  1152  
  1153  func (m *modelsDef) vpcRouterPPTPServer() *dsl.Model {
  1154  	return &dsl.Model{
  1155  		Name:      "VPCRouterPPTPServer",
  1156  		NakedType: meta.Static(naked.VPCRouterPPTPServerConfig{}),
  1157  		Fields: []*dsl.FieldDesc{
  1158  			{
  1159  				Name: "RangeStart",
  1160  				Type: meta.TypeString,
  1161  			},
  1162  			{
  1163  				Name: "RangeStop",
  1164  				Type: meta.TypeString,
  1165  			},
  1166  		},
  1167  	}
  1168  }
  1169  
  1170  func (m *modelsDef) vpcRouterL2TPIPsecServer() *dsl.Model {
  1171  	return &dsl.Model{
  1172  		Name:      "VPCRouterL2TPIPsecServer",
  1173  		NakedType: meta.Static(naked.VPCRouterL2TPIPsecServerConfig{}),
  1174  		Fields: []*dsl.FieldDesc{
  1175  			{
  1176  				Name: "RangeStart",
  1177  				Type: meta.TypeString,
  1178  			},
  1179  			{
  1180  				Name: "RangeStop",
  1181  				Type: meta.TypeString,
  1182  			},
  1183  			{
  1184  				Name: "PreSharedSecret",
  1185  				Type: meta.TypeString,
  1186  			},
  1187  		},
  1188  	}
  1189  }
  1190  
  1191  func (m *modelsDef) vpcRouterWireGuard() *dsl.Model {
  1192  	return &dsl.Model{
  1193  		Name:      "VPCRouterWireGuard",
  1194  		NakedType: meta.Static(naked.VPCRouterWireGuardConfig{}),
  1195  		Fields: []*dsl.FieldDesc{
  1196  			{
  1197  				Name: "IPAddress",
  1198  				Type: meta.TypeString,
  1199  			},
  1200  			{
  1201  				Name: "Peers",
  1202  				Tags: &dsl.FieldTags{
  1203  					MapConv: "[]Peers,omitempty,recursive",
  1204  				},
  1205  				Type: m.vpcRouterWireGuardPeer(),
  1206  			},
  1207  		},
  1208  	}
  1209  }
  1210  
  1211  func (m *modelsDef) vpcRouterWireGuardPeer() *dsl.Model {
  1212  	return &dsl.Model{
  1213  		Name:      "VPCRouterWireGuardPeer",
  1214  		NakedType: meta.Static(naked.VPCRouterWireGuardPeer{}),
  1215  		IsArray:   true,
  1216  		Fields: []*dsl.FieldDesc{
  1217  			{
  1218  				Name: "Name",
  1219  				Type: meta.TypeString,
  1220  			},
  1221  			{
  1222  				Name: "IPAddress",
  1223  				Type: meta.TypeString,
  1224  			},
  1225  			{
  1226  				Name: "PublicKey",
  1227  				Type: meta.TypeString,
  1228  			},
  1229  		},
  1230  	}
  1231  }
  1232  
  1233  func (m *modelsDef) vpcRouterRemoteAccessUser() *dsl.Model {
  1234  	return &dsl.Model{
  1235  		Name:      "VPCRouterRemoteAccessUser",
  1236  		NakedType: meta.Static(naked.VPCRouterRemoteAccessUserConfig{}),
  1237  		IsArray:   true,
  1238  		Fields: []*dsl.FieldDesc{
  1239  			{
  1240  				Name: "UserName",
  1241  				Type: meta.TypeString,
  1242  			},
  1243  			{
  1244  				Name: "Password",
  1245  				Type: meta.TypeString,
  1246  			},
  1247  		},
  1248  	}
  1249  }
  1250  
  1251  func (m *modelsDef) vpcRouterSiteToSiteIPsecVPN() *dsl.Model {
  1252  	return &dsl.Model{
  1253  		Name:      "VPCRouterSiteToSiteIPsecVPN",
  1254  		NakedType: meta.Static(naked.VPCRouterSiteToSiteIPsecVPN{}),
  1255  		Fields: []*dsl.FieldDesc{
  1256  			{
  1257  				Name: "Config",
  1258  				Type: m.vpcRouterSiteToSiteIPsecVPNConfig(),
  1259  				Tags: &dsl.FieldTags{
  1260  					MapConv: "[]Config,omitempty,recursive",
  1261  				},
  1262  			},
  1263  			{
  1264  				Name: "IKE",
  1265  				Type: m.vpcRouterSiteToSiteIPsecVPNIKE(),
  1266  				Tags: &dsl.FieldTags{
  1267  					MapConv: ",omitempty,recursive",
  1268  				},
  1269  			},
  1270  			{
  1271  				Name: "ESP",
  1272  				Type: m.vpcRouterSiteToSiteIPsecVPNESP(),
  1273  				Tags: &dsl.FieldTags{
  1274  					MapConv: ",omitempty,recursive",
  1275  				},
  1276  			},
  1277  			{
  1278  				Name: "EncryptionAlgo",
  1279  				Type: meta.TypeString,
  1280  			},
  1281  			{
  1282  				Name: "HashAlgo",
  1283  				Type: meta.TypeString,
  1284  			},
  1285  			{
  1286  				Name: "DHGroup",
  1287  				Type: meta.TypeString,
  1288  			},
  1289  		},
  1290  	}
  1291  }
  1292  
  1293  func (m *modelsDef) vpcRouterSiteToSiteIPsecVPNConfig() *dsl.Model {
  1294  	return &dsl.Model{
  1295  		Name:      "VPCRouterSiteToSiteIPsecVPNConfig",
  1296  		NakedType: meta.Static(naked.VPCRouterSiteToSiteIPsecVPNConfig{}),
  1297  		IsArray:   true,
  1298  		Fields: []*dsl.FieldDesc{
  1299  			{
  1300  				Name: "Peer",
  1301  				Type: meta.TypeString,
  1302  			},
  1303  			{
  1304  				Name: "PreSharedSecret",
  1305  				Type: meta.TypeString,
  1306  			},
  1307  			{
  1308  				Name: "RemoteID",
  1309  				Type: meta.TypeString,
  1310  			},
  1311  			{
  1312  				Name: "Routes",
  1313  				Type: meta.TypeStringSlice,
  1314  			},
  1315  			{
  1316  				Name: "LocalPrefix",
  1317  				Type: meta.TypeStringSlice,
  1318  			},
  1319  		},
  1320  	}
  1321  }
  1322  
  1323  func (m *modelsDef) vpcRouterSiteToSiteIPsecVPNIKE() *dsl.Model {
  1324  	return &dsl.Model{
  1325  		Name:      "VPCRouterSiteToSiteIPsecVPNIKE",
  1326  		NakedType: meta.Static(naked.VPCRouterSiteToSiteIPsecVPNIKE{}),
  1327  		Fields: []*dsl.FieldDesc{
  1328  			{
  1329  				Name: "Lifetime",
  1330  				Type: meta.TypeInt,
  1331  			},
  1332  			{
  1333  				Name: "DPD",
  1334  				Type: m.vpcRouterSiteToSiteIPsecVPNIKEDPD(),
  1335  				Tags: &dsl.FieldTags{
  1336  					MapConv: ",omitempty,recursive",
  1337  				},
  1338  			},
  1339  		},
  1340  	}
  1341  }
  1342  
  1343  func (m *modelsDef) vpcRouterSiteToSiteIPsecVPNIKEDPD() *dsl.Model {
  1344  	return &dsl.Model{
  1345  		Name:      "VPCRouterSiteToSiteIPsecVPNIKEDPD",
  1346  		NakedType: meta.Static(naked.VPCRouterSiteToSiteIPsecVPNIKEDPD{}),
  1347  		Fields: []*dsl.FieldDesc{
  1348  			{
  1349  				Name: "Interval",
  1350  				Type: meta.TypeInt,
  1351  			},
  1352  			{
  1353  				Name: "Timeout",
  1354  				Type: meta.TypeInt,
  1355  			},
  1356  		},
  1357  	}
  1358  }
  1359  
  1360  func (m *modelsDef) vpcRouterSiteToSiteIPsecVPNESP() *dsl.Model {
  1361  	return &dsl.Model{
  1362  		Name:      "VPCRouterSiteToSiteIPsecVPNESP",
  1363  		NakedType: meta.Static(naked.VPCRouterSiteToSiteIPsecVPNESP{}),
  1364  		Fields: []*dsl.FieldDesc{
  1365  			{
  1366  				Name: "Lifetime",
  1367  				Type: meta.TypeInt,
  1368  			},
  1369  		},
  1370  	}
  1371  }
  1372  
  1373  func (m *modelsDef) vpcRouterStaticRoute() *dsl.Model {
  1374  	return &dsl.Model{
  1375  		Name:      "VPCRouterStaticRoute",
  1376  		NakedType: meta.Static(naked.VPCRouterStaticRouteConfig{}),
  1377  		IsArray:   true,
  1378  		Fields: []*dsl.FieldDesc{
  1379  			{
  1380  				Name: "Prefix",
  1381  				Type: meta.TypeString,
  1382  			},
  1383  			{
  1384  				Name: "NextHop",
  1385  				Type: meta.TypeString,
  1386  			},
  1387  		},
  1388  	}
  1389  }
  1390  
  1391  func (m *modelsDef) vpcRouterScheduledMaintenance() *dsl.Model {
  1392  	return &dsl.Model{
  1393  		Name:      "VPCRouterScheduledMaintenance",
  1394  		NakedType: meta.Static(naked.VPCRouterScheduledMaintenance{}),
  1395  		Fields: []*dsl.FieldDesc{
  1396  			{
  1397  				Name: "DayOfWeek",
  1398  				Type: meta.TypeInt,
  1399  			},
  1400  			{
  1401  				Name: "Hour",
  1402  				Type: meta.TypeInt,
  1403  			},
  1404  		},
  1405  	}
  1406  }
  1407  
  1408  func (m *modelsDef) vpcRouterSessionAnalyticsValue() *dsl.Model {
  1409  	return &dsl.Model{
  1410  		Name:      "VPCRouterStatisticsValue",
  1411  		NakedType: meta.Static(naked.VPCRouterStatisticsValue{}),
  1412  		IsArray:   true,
  1413  		Fields: []*dsl.FieldDesc{
  1414  			{
  1415  				Name: "Name",
  1416  				Type: meta.TypeString,
  1417  			},
  1418  			{
  1419  				Name: "Count",
  1420  				Type: meta.TypeInt,
  1421  			},
  1422  		},
  1423  	}
  1424  }
  1425  
  1426  // ******************************************************************************
  1427  // Mobile Gateway
  1428  // ******************************************************************************
  1429  
  1430  func (m *modelsDef) mobileGatewayInterface() *dsl.Model {
  1431  	return &dsl.Model{
  1432  		Name:      "MobileGatewayInterfaceSetting",
  1433  		NakedType: meta.Static(naked.MobileGatewayInterface{}),
  1434  		IsArray:   true,
  1435  		Fields: []*dsl.FieldDesc{
  1436  			fields.Def("IPAddress", meta.TypeStringSlice),
  1437  			fields.Def("NetworkMaskLen", meta.TypeInt),
  1438  			fields.Def("Index", meta.TypeInt),
  1439  		},
  1440  	}
  1441  }
  1442  
  1443  func (m *modelsDef) mobileGatewayStaticRoute() *dsl.Model {
  1444  	return &dsl.Model{
  1445  		Name:      "MobileGatewayStaticRoute",
  1446  		NakedType: meta.Static(naked.MobileGatewayStaticRoute{}),
  1447  		IsArray:   true,
  1448  		Fields: []*dsl.FieldDesc{
  1449  			fields.Def("Prefix", meta.TypeString),
  1450  			fields.Def("NextHop", meta.TypeString),
  1451  		},
  1452  	}
  1453  }
  1454  
  1455  // ******************************************************************************
  1456  // SIM
  1457  // ******************************************************************************
  1458  
  1459  func (m *modelsDef) simInfo() *dsl.Model {
  1460  	return &dsl.Model{
  1461  		Name:      "SIMInfo",
  1462  		NakedType: meta.Static(naked.SIMInfo{}),
  1463  		Fields:    m.simInfoFields(),
  1464  	}
  1465  }
  1466  
  1467  func (m *modelsDef) simInfoList() *dsl.Model {
  1468  	return &dsl.Model{
  1469  		Name:      "MobileGatewaySIMInfo",
  1470  		Alias:     "MobileGatewaySIMs",
  1471  		NakedType: meta.Static(naked.SIMInfo{}),
  1472  		Fields:    m.simInfoFields(),
  1473  	}
  1474  }
  1475  
  1476  func (m *modelsDef) simInfoFields() []*dsl.FieldDesc {
  1477  	return []*dsl.FieldDesc{
  1478  		fields.Def("ICCID", meta.TypeString),
  1479  		fields.Def("IMSI", meta.TypeStringSlice),
  1480  		fields.Def("IMEI", meta.TypeString),
  1481  		fields.Def("IP", meta.TypeString),
  1482  		fields.Def("SessionStatus", meta.TypeString),
  1483  		fields.Def("IMEILock", meta.TypeFlag),
  1484  		fields.Def("Registered", meta.TypeFlag),
  1485  		fields.Def("Activated", meta.TypeFlag),
  1486  		fields.Def("ResourceID", meta.TypeString),
  1487  		fields.Def("RegisteredDate", meta.TypeTime),
  1488  		fields.Def("ActivatedDate", meta.TypeTime),
  1489  		fields.Def("DeactivatedDate", meta.TypeTime),
  1490  		fields.Def("SIMGroupID", meta.TypeString),
  1491  		{
  1492  			Name: "TrafficBytesOfCurrentMonth",
  1493  			Type: &dsl.Model{
  1494  				Name: "SIMTrafficBytes",
  1495  				Fields: []*dsl.FieldDesc{
  1496  					fields.Def("UplinkBytes", meta.TypeInt64),
  1497  					fields.Def("DownlinkBytes", meta.TypeInt64),
  1498  				},
  1499  			},
  1500  			Tags: &dsl.FieldTags{
  1501  				MapConv: ",recursive",
  1502  			},
  1503  		},
  1504  		fields.Def("ConnectedIMEI", meta.TypeString),
  1505  	}
  1506  }
  1507  
  1508  func (m *modelsDef) migrationJobStatus() *dsl.Model {
  1509  	return &dsl.Model{
  1510  		Name:      "JobStatus",
  1511  		NakedType: meta.Static(naked.MigrationJobStatus{}),
  1512  		Fields: []*dsl.FieldDesc{
  1513  			fields.Def("Status", meta.TypeString),
  1514  			fields.Def("ConfigError", &dsl.Model{
  1515  				Name:      "JobConfigError",
  1516  				NakedType: meta.Static(naked.JobConfigError{}),
  1517  				Fields: []*dsl.FieldDesc{
  1518  					fields.Def("ErrorCode", meta.TypeString),
  1519  					fields.Def("ErrorMsg", meta.TypeString),
  1520  					fields.Def("Status", meta.TypeString),
  1521  				},
  1522  			}),
  1523  		},
  1524  	}
  1525  }