cmd

var Assets = assets.NewFileSystem(map[string][]string{"/": {"soracom-api.en.yaml", "soracom-api.ja.yaml"}, "/cli": {"en.yaml", "ja.yaml"}, "/sandbox": {"soracom-sandbox-api.en.yaml", "soracom-sandbox-api.ja.yaml"}}, map[string]*assets.File{
	"/cli": {
		Path:     "/cli",
		FileMode: 0x800001fd,
		Mtime:    time.Unix(1594891716, 1594891716863907812),
		Data:     nil,
	}, "/sandbox": {
		Path:     "/sandbox",
		FileMode: 0x800001fd,
		Mtime:    time.Unix(1589532330, 1589532330074102612),
		Data:     nil,
	}, "/sandbox/soracom-sandbox-api.en.yaml": {
		Path:     "/sandbox/soracom-sandbox-api.en.yaml",
		FileMode: 0x1b4,
		Mtime:    time.Unix(1594876908, 1594876908239533807),
		Data:     []byte(_Assets97a20b3222934f45582ee03978d9d580a7ac794a),
	}, "/sandbox/soracom-sandbox-api.ja.yaml": {
		Path:     "/sandbox/soracom-sandbox-api.ja.yaml",
		FileMode: 0x1b4,
		Mtime:    time.Unix(1594876908, 1594876908243533807),
		Data:     []byte(_Assetsf42da71514797c324cbb698b0b797762ff9918a7),
	}, "/": {
		Path:     "/",
		FileMode: 0x800001fd,
		Mtime:    time.Unix(1594943683, 1594943683416849043),
		Data:     nil,
	}, "/cli/en.yaml": {
		Path:     "/cli/en.yaml",
		FileMode: 0x1b4,
		Mtime:    time.Unix(1594891716, 1594891716863907812),
		Data:     []byte(_Assets5c7a5c077bf08178252e3232f159748d3047d4e1),
	}, "/cli/ja.yaml": {
		Path:     "/cli/ja.yaml",
		FileMode: 0x1b4,
		Mtime:    time.Unix(1594891716, 1594891716863907812),
		Data:     []byte(_Assetsc656f9a20bab5c445f670257a18d5d8b67a927b2),
	}, "/soracom-api.en.yaml": {
		Path:     "/soracom-api.en.yaml",
		FileMode: 0x1fd,
		Mtime:    time.Unix(1594943683, 1594943683416849043),
		Data:     []byte(_Assets0764b782d9c1bd06ad125db0a570e6abd04c472c),
	}, "/soracom-api.ja.yaml": {
		Path:     "/soracom-api.ja.yaml",
		FileMode: 0x1fd,
		Mtime:    time.Unix(1594943683, 1594943683416849043),
		Data:     []byte(_Assets6869369ac6cbeb59ff80562bf70e125cfe403b8c),
	}}, "")

var AuditLogsCmd = &cobra.Command{
	Use:   "audit-logs",
	Short: TRCLI("cli.audit-logs.summary"),
	Long:  TRCLI(`cli.audit-logs.description`),
}

var AuditLogsNapterCmd = &cobra.Command{
	Use:   "napter",
	Short: TRCLI("cli.audit-logs.napter.summary"),
	Long:  TRCLI(`cli.audit-logs.napter.description`),
}

var AuditLogsNapterGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/audit_logs/napter:get:summary"),
	Long:  TRAPI(`/audit_logs/napter:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectAuditLogsNapterGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var AuditLogsNapterGetCmdFrom int64

var AuditLogsNapterGetCmdLastEvaluatedKey string

var AuditLogsNapterGetCmdLimit int64

var AuditLogsNapterGetCmdPaginate bool

var AuditLogsNapterGetCmdResourceId string

var AuditLogsNapterGetCmdResourceType string

var AuditLogsNapterGetCmdTo int64

var AuthCmd = &cobra.Command{
	Use:   "auth",
	Short: TRAPI("/auth:post:summary"),
	Long:  TRAPI(`/auth:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectAuthCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var AuthCmdAuthKey string

var AuthCmdAuthKeyId string

var AuthCmdBody string

var AuthCmdEmail string

var AuthCmdMfaOTPCode string

var AuthCmdOperatorId string

var AuthCmdPassword string

var AuthCmdTokenTimeoutSeconds int64

var AuthCmdUserName string

var AuthIssuePasswordResetTokenCmd = &cobra.Command{
	Use:   "issue-password-reset-token",
	Short: TRAPI("/auth/password_reset_token/issue:post:summary"),
	Long:  TRAPI(`/auth/password_reset_token/issue:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectAuthIssuePasswordResetTokenCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var AuthIssuePasswordResetTokenCmdBody string

var AuthIssuePasswordResetTokenCmdEmail string

var AuthVerifyPasswordResetTokenCmd = &cobra.Command{
	Use:   "verify-password-reset-token",
	Short: TRAPI("/auth/password_reset_token/verify:post:summary"),
	Long:  TRAPI(`/auth/password_reset_token/verify:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectAuthVerifyPasswordResetTokenCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var AuthVerifyPasswordResetTokenCmdBody string

var AuthVerifyPasswordResetTokenCmdPassword string

var AuthVerifyPasswordResetTokenCmdToken string

var BillsCmd = &cobra.Command{
	Use:   "bills",
	Short: TRCLI("cli.bills.summary"),
	Long:  TRCLI(`cli.bills.description`),
}

var BillsExportCmd = &cobra.Command{
	Use:   "export",
	Short: TRAPI("/bills/{yyyyMM}/export:post:summary"),
	Long:  TRAPI(`/bills/{yyyyMM}/export:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectBillsExportCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var BillsExportCmdExportMode string

var BillsExportCmdYyyyMM string

var BillsExportLatestCmd = &cobra.Command{
	Use:   "export-latest",
	Short: TRAPI("/bills/latest/export:post:summary"),
	Long:  TRAPI(`/bills/latest/export:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectBillsExportLatestCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var BillsExportLatestCmdExportMode string

var BillsGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/bills/{yyyyMM}:get:summary"),
	Long:  TRAPI(`/bills/{yyyyMM}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectBillsGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var BillsGetCmdYyyyMM string

var BillsGetDailyCmd = &cobra.Command{
	Use:   "get-daily",
	Short: TRAPI("/bills/{yyyyMM}/daily:get:summary"),
	Long:  TRAPI(`/bills/{yyyyMM}/daily:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectBillsGetDailyCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var BillsGetDailyCmdYyyyMM string

var BillsGetLatestCmd = &cobra.Command{
	Use:   "get-latest",
	Short: TRAPI("/bills/latest:get:summary"),
	Long:  TRAPI(`/bills/latest:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectBillsGetLatestCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var BillsListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/bills:get:summary"),
	Long:  TRAPI(`/bills:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectBillsListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var CompletionBashCmd = &cobra.Command{
	Use:   "bash",
	Short: TRCLI("cli.completion.bash.summary"),
	Long:  TRCLI("cli.completion.bash.description"),
	RunE: func(cmd *cobra.Command, args []string) error {
		err := RootCmd.GenBashCompletion(os.Stdout)
		if err != nil {
			return err
		}
		return nil
	},
}

var CompletionCmd = &cobra.Command{
	Use:   "completion",
	Short: TRCLI("cli.completion.summary"),
	Long:  TRCLI("cli.completion.description"),
	RunE: func(cmd *cobra.Command, args []string) error {

		err := RootCmd.GenBashCompletion(os.Stdout)
		if err != nil {
			return err
		}
		return nil
	},
}

var CompletionZshCmd = &cobra.Command{
	Use:   "zsh",
	Short: TRCLI("cli.completion.zsh.summary"),
	Long:  TRCLI("cli.completion.zsh.description"),
	RunE: func(cmd *cobra.Command, args []string) error {
		err := RootCmd.GenZshCompletion(os.Stdout)
		if err != nil {
			return err
		}
		return nil
	},
}

var ConfigureCmd = &cobra.Command{
	Use:   "configure",
	Short: TRCLI("cli.configure.summary"),
	Long:  TRCLI("cli.configure.description"),
	RunE: func(cmd *cobra.Command, args []string) error {
		pn := getSpecifiedProfileName()
		if pn == "" {
			pn = "default"
		}

		profile, err := collectProfileInfo(pn)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		err = saveProfile(pn, profile)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		return nil
	},
}

var ConfigureGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRCLI("cli.configure.get.summary"),
	Long:  TRCLI("cli.configure.get.description"),
	RunE: func(cmd *cobra.Command, args []string) error {
		pn := getSpecifiedProfileName()
		if pn == "" {
			pn = "default"
		}

		p, err := loadProfile(pn)
		if err != nil {
			return err
		}

		return prettyPrintObjectAsJSON(p)
	},
}

var ConfigureSandboxAuthKey string

var ConfigureSandboxAuthKeyID string

var ConfigureSandboxCmd = &cobra.Command{
	Use:   "configure-sandbox",
	Short: TRCLI("cli.configure_sandbox.summary"),
	Long:  TRCLI("cli.configure_sandbox.description"),
	RunE: func(cmd *cobra.Command, args []string) error {
		pn := getSpecifiedSandboxProfileName()

		var p *profile
		var err error
		if ConfigureSandboxAuthKeyID == "" || ConfigureSandboxAuthKey == "" || ConfigureSandboxEmail == "" || ConfigureSandboxPassword == "" {
			p, err = collectSandboxProfileInfo(pn, ConfigureSandboxRegisterPaymentMethod)
			if err != nil {
				cmd.SilenceUsage = true
				return err
			}
			ep := getSpecifiedSandboxEndpoint(p.CoverageType)
			p.Endpoint = &ep
		} else {
			ct := getSpecifiedCoverageType()
			ep := getSpecifiedSandboxEndpoint(ct)
			p = &profile{
				Sandbox:               true,
				CoverageType:          ct,
				Endpoint:              &ep,
				AuthKeyID:             &ConfigureSandboxAuthKeyID,
				AuthKey:               &ConfigureSandboxAuthKey,
				Email:                 &ConfigureSandboxEmail,
				Password:              &ConfigureSandboxPassword,
				RegisterPaymentMethod: ConfigureSandboxRegisterPaymentMethod,
			}
		}

		_, err = sandboxInit(p)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		p.AuthKeyID = nil
		p.AuthKey = nil

		err = saveProfile(pn, p)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		return nil
	},
}

var ConfigureSandboxEmail string

var ConfigureSandboxPassword string

var ConfigureSandboxRegisterPaymentMethod bool

var CouponsCmd = &cobra.Command{
	Use:   "coupons",
	Short: TRCLI("cli.coupons.summary"),
	Long:  TRCLI(`cli.coupons.description`),
}

var CouponsListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/coupons:get:summary"),
	Long:  TRAPI(`/coupons:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectCouponsListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var CouponsRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TRAPI("/coupons/{coupon_code}/register:post:summary"),
	Long:  TRAPI(`/coupons/{coupon_code}/register:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectCouponsRegisterCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var CouponsRegisterCmdCouponCode string

var CredentialsCmd = &cobra.Command{
	Use:   "credentials",
	Short: TRCLI("cli.credentials.summary"),
	Long:  TRCLI(`cli.credentials.description`),
}

var CredentialsCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TRAPI("/credentials/{credentials_id}:post:summary"),
	Long:  TRAPI(`/credentials/{credentials_id}:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectCredentialsCreateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var CredentialsCreateCmdBody string

var CredentialsCreateCmdCredentialsId string

var CredentialsCreateCmdDescription string

var CredentialsCreateCmdType string

var CredentialsDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TRAPI("/credentials/{credentials_id}:delete:summary"),
	Long:  TRAPI(`/credentials/{credentials_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectCredentialsDeleteCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var CredentialsDeleteCmdCredentialsId string

var CredentialsListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/credentials:get:summary"),
	Long:  TRAPI(`/credentials:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectCredentialsListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var CredentialsUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TRAPI("/credentials/{credentials_id}:put:summary"),
	Long:  TRAPI(`/credentials/{credentials_id}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectCredentialsUpdateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var CredentialsUpdateCmdBody string

var CredentialsUpdateCmdCredentialsId string

var CredentialsUpdateCmdDescription string

var CredentialsUpdateCmdType string

var DataCmd = &cobra.Command{
	Use:   "data",
	Short: TRCLI("cli.data.summary"),
	Long:  TRCLI(`cli.data.description`),
}

var DataDeleteEntryCmd = &cobra.Command{
	Use:   "delete-entry",
	Short: TRAPI("/data/{resource_type}/{resource_id}/{time}:delete:summary"),
	Long:  TRAPI(`/data/{resource_type}/{resource_id}/{time}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDataDeleteEntryCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DataDeleteEntryCmdResourceId string

var DataDeleteEntryCmdResourceType string

var DataDeleteEntryCmdTime int64

var DataGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/sims/{sim_id}/data:get:summary"),
	Long:  TRAPI(`/sims/{sim_id}/data:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDataGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DataGetCmdFrom int64

var DataGetCmdLastEvaluatedKey string

var DataGetCmdLimit int64

var DataGetCmdSimId string

var DataGetCmdSort string

var DataGetCmdTo int64

var DataGetEntriesCmd = &cobra.Command{
	Use:   "get-entries",
	Short: TRAPI("/data/{resource_type}/{resource_id}:get:summary"),
	Long:  TRAPI(`/data/{resource_type}/{resource_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDataGetEntriesCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DataGetEntriesCmdFrom int64

var DataGetEntriesCmdLastEvaluatedKey string

var DataGetEntriesCmdLimit int64

var DataGetEntriesCmdPaginate bool

var DataGetEntriesCmdResourceId string

var DataGetEntriesCmdResourceType string

var DataGetEntriesCmdSort string

var DataGetEntriesCmdTo int64

var DataGetEntryCmd = &cobra.Command{
	Use:   "get-entry",
	Short: TRAPI("/data/{resource_type}/{resource_id}/{time}:get:summary"),
	Long:  TRAPI(`/data/{resource_type}/{resource_id}/{time}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDataGetEntryCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DataGetEntryCmdResourceId string

var DataGetEntryCmdResourceType string

var DataGetEntryCmdTime int64

var DataListSourceResourcesCmd = &cobra.Command{
	Use:   "list-source-resources",
	Short: TRAPI("/data/resources:get:summary"),
	Long:  TRAPI(`/data/resources:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDataListSourceResourcesCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DataListSourceResourcesCmdLastEvaluatedKey string

var DataListSourceResourcesCmdLimit int64

var DataListSourceResourcesCmdPaginate bool

var DataListSourceResourcesCmdResourceType string

var DevicesCmd = &cobra.Command{
	Use:   "devices",
	Short: TRCLI("cli.devices.summary"),
	Long:  TRCLI(`cli.devices.description`),
}

var DevicesCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TRAPI("/devices:post:summary"),
	Long:  TRAPI(`/devices:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesCreateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesCreateCmdBody string

var DevicesCreateCmdDeviceId string

var DevicesCreateCmdEndpoint string

var DevicesCreateCmdFirmwareVersion string

var DevicesCreateCmdGroupId string

var DevicesCreateCmdIpAddress string

var DevicesCreateCmdLastModifiedTime string

var DevicesCreateCmdLastRegistrationUpdate string

var DevicesCreateCmdManufacturer string

var DevicesCreateCmdModelNumber string

var DevicesCreateCmdOnline bool

var DevicesCreateCmdOperatorId string

var DevicesCreateCmdRegistrationId string

var DevicesCreateCmdRegistrationLifeTime int64

var DevicesCreateCmdSerialNumber string

var DevicesCreateObjectModelCmd = &cobra.Command{
	Use:   "create-object-model",
	Short: TRAPI("/device_object_models:post:summary"),
	Long:  TRAPI(`/device_object_models:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesCreateObjectModelCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesCreateObjectModelCmdBody string

var DevicesCreateObjectModelCmdCreatedTime string

var DevicesCreateObjectModelCmdFormat string

var DevicesCreateObjectModelCmdLastModifiedTime string

var DevicesCreateObjectModelCmdObjectId string

var DevicesCreateObjectModelCmdObjectName string

var DevicesCreateObjectModelCmdOperatorId string

var DevicesCreateObjectModelCmdScope string

var DevicesDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TRAPI("/devices/{device_id}:delete:summary"),
	Long:  TRAPI(`/devices/{device_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesDeleteCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesDeleteCmdDeviceId string

var DevicesDeleteDeviceTagCmd = &cobra.Command{
	Use:   "delete-device-tag",
	Short: TRAPI("/devices/{device_id}/tags/{tag_name}:delete:summary"),
	Long:  TRAPI(`/devices/{device_id}/tags/{tag_name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesDeleteDeviceTagCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesDeleteDeviceTagCmdDeviceId string

var DevicesDeleteDeviceTagCmdTagName string

var DevicesDeleteObjectModelCmd = &cobra.Command{
	Use:   "delete-object-model",
	Short: TRAPI("/device_object_models/{model_id}:delete:summary"),
	Long:  TRAPI(`/device_object_models/{model_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesDeleteObjectModelCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesDeleteObjectModelCmdModelId string

var DevicesExecuteResourceCmd = &cobra.Command{
	Use:   "execute-resource",
	Short: TRAPI("/devices/{device_id}/{object}/{instance}/{resource}/execute:post:summary"),
	Long:  TRAPI(`/devices/{device_id}/{object}/{instance}/{resource}/execute:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesExecuteResourceCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesExecuteResourceCmdBody string

var DevicesExecuteResourceCmdDeviceId string

var DevicesExecuteResourceCmdInstance string

var DevicesExecuteResourceCmdObject string

var DevicesExecuteResourceCmdResource string

var DevicesGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/devices/{device_id}:get:summary"),
	Long:  TRAPI(`/devices/{device_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesGetCmdDeviceId string

var DevicesGetCmdModel bool

var DevicesGetDataCmd = &cobra.Command{
	Use:   "get-data",
	Short: TRAPI("/devices/{device_id}/data:get:summary"),
	Long:  TRAPI(`/devices/{device_id}/data:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesGetDataCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesGetDataCmdDeviceId string

var DevicesGetDataCmdFrom int64

var DevicesGetDataCmdLastEvaluatedKey string

var DevicesGetDataCmdLimit int64

var DevicesGetDataCmdPaginate bool

var DevicesGetDataCmdSort string

var DevicesGetDataCmdTo int64

var DevicesGetInstanceCmd = &cobra.Command{
	Use:   "get-instance",
	Short: TRAPI("/devices/{device_id}/{object}/{instance}:get:summary"),
	Long:  TRAPI(`/devices/{device_id}/{object}/{instance}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesGetInstanceCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesGetInstanceCmdDeviceId string

var DevicesGetInstanceCmdInstance string

var DevicesGetInstanceCmdModel bool

var DevicesGetInstanceCmdObject string

var DevicesGetObjectModelCmd = &cobra.Command{
	Use:   "get-object-model",
	Short: TRAPI("/device_object_models/{model_id}:get:summary"),
	Long:  TRAPI(`/device_object_models/{model_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesGetObjectModelCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesGetObjectModelCmdModelId string

var DevicesGetResourceCmd = &cobra.Command{
	Use:   "get-resource",
	Short: TRAPI("/devices/{device_id}/{object}/{instance}/{resource}:get:summary"),
	Long:  TRAPI(`/devices/{device_id}/{object}/{instance}/{resource}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesGetResourceCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesGetResourceCmdDeviceId string

var DevicesGetResourceCmdInstance string

var DevicesGetResourceCmdModel bool

var DevicesGetResourceCmdObject string

var DevicesGetResourceCmdResource string

var DevicesListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/devices:get:summary"),
	Long:  TRAPI(`/devices:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesListCmdLastEvaluatedKey string

var DevicesListCmdLimit int64

var DevicesListCmdPaginate bool

var DevicesListCmdTagName string

var DevicesListCmdTagValue string

var DevicesListCmdTagValueMatchMode string

var DevicesListObjectModelsCmd = &cobra.Command{
	Use:   "list-object-models",
	Short: TRAPI("/device_object_models:get:summary"),
	Long:  TRAPI(`/device_object_models:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesListObjectModelsCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesListObjectModelsCmdLastEvaluatedKey string

var DevicesListObjectModelsCmdLimit int64

var DevicesListObjectModelsCmdPaginate bool

var DevicesObserveResourceCmd = &cobra.Command{
	Use:   "observe-resource",
	Short: TRAPI("/devices/{device_id}/{object}/{instance}/{resource}/observe:post:summary"),
	Long:  TRAPI(`/devices/{device_id}/{object}/{instance}/{resource}/observe:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesObserveResourceCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesObserveResourceCmdDeviceId string

var DevicesObserveResourceCmdInstance string

var DevicesObserveResourceCmdModel bool

var DevicesObserveResourceCmdObject string

var DevicesObserveResourceCmdResource string

var DevicesObserveResourcesCmd = &cobra.Command{
	Use:   "observe-resources",
	Short: TRAPI("/devices/{device_id}/{object}/{instance}/observe:post:summary"),
	Long:  TRAPI(`/devices/{device_id}/{object}/{instance}/observe:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesObserveResourcesCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesObserveResourcesCmdDeviceId string

var DevicesObserveResourcesCmdInstance string

var DevicesObserveResourcesCmdModel bool

var DevicesObserveResourcesCmdObject string

var DevicesPutDeviceTagsCmd = &cobra.Command{
	Use:   "put-device-tags",
	Short: TRAPI("/devices/{device_id}/tags:put:summary"),
	Long:  TRAPI(`/devices/{device_id}/tags:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesPutDeviceTagsCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesPutDeviceTagsCmdBody string

var DevicesPutDeviceTagsCmdDeviceId string

var DevicesPutResourceCmd = &cobra.Command{
	Use:   "put-resource",
	Short: TRAPI("/devices/{device_id}/{object}/{instance}/{resource}:put:summary"),
	Long:  TRAPI(`/devices/{device_id}/{object}/{instance}/{resource}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesPutResourceCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesPutResourceCmdBody string

var DevicesPutResourceCmdDeviceId string

var DevicesPutResourceCmdInstance string

var DevicesPutResourceCmdObject string

var DevicesPutResourceCmdResource string

var DevicesSetGroupCmd = &cobra.Command{
	Use:   "set-group",
	Short: TRAPI("/devices/{device_id}/set_group:post:summary"),
	Long:  TRAPI(`/devices/{device_id}/set_group:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesSetGroupCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesSetGroupCmdBody string

var DevicesSetGroupCmdDeviceId string

var DevicesSetObjectModelScopeCmd = &cobra.Command{
	Use:   "set-object-model-scope",
	Short: TRAPI("/device_object_models/{model_id}/set_scope:post:summary"),
	Long:  TRAPI(`/device_object_models/{model_id}/set_scope:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesSetObjectModelScopeCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesSetObjectModelScopeCmdBody string

var DevicesSetObjectModelScopeCmdModelId string

var DevicesSetObjectModelScopeCmdScope string

var DevicesUnobserveResourceCmd = &cobra.Command{
	Use:   "unobserve-resource",
	Short: TRAPI("/devices/{device_id}/{object}/{instance}/{resource}/unobserve:post:summary"),
	Long:  TRAPI(`/devices/{device_id}/{object}/{instance}/{resource}/unobserve:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesUnobserveResourceCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesUnobserveResourceCmdDeviceId string

var DevicesUnobserveResourceCmdInstance string

var DevicesUnobserveResourceCmdObject string

var DevicesUnobserveResourceCmdResource string

var DevicesUnobserveResourcesCmd = &cobra.Command{
	Use:   "unobserve-resources",
	Short: TRAPI("/devices/{device_id}/{object}/{instance}/unobserve:post:summary"),
	Long:  TRAPI(`/devices/{device_id}/{object}/{instance}/unobserve:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesUnobserveResourcesCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesUnobserveResourcesCmdDeviceId string

var DevicesUnobserveResourcesCmdInstance string

var DevicesUnobserveResourcesCmdObject string

var DevicesUnsetGroupCmd = &cobra.Command{
	Use:   "unset-group",
	Short: TRAPI("/devices/{device_id}/unset_group:post:summary"),
	Long:  TRAPI(`/devices/{device_id}/unset_group:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesUnsetGroupCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesUnsetGroupCmdDeviceId string

var DevicesUpdateObjectModelCmd = &cobra.Command{
	Use:   "update-object-model",
	Short: TRAPI("/device_object_models/{model_id}:post:summary"),
	Long:  TRAPI(`/device_object_models/{model_id}:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectDevicesUpdateObjectModelCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var DevicesUpdateObjectModelCmdBody string

var DevicesUpdateObjectModelCmdCreatedTime string

var DevicesUpdateObjectModelCmdFormat string

var DevicesUpdateObjectModelCmdLastModifiedTime string

var DevicesUpdateObjectModelCmdModelId string

var DevicesUpdateObjectModelCmdObjectId string

var DevicesUpdateObjectModelCmdObjectName string

var DevicesUpdateObjectModelCmdOperatorId string

var DevicesUpdateObjectModelCmdScope string

var EventHandlersCmd = &cobra.Command{
	Use:   "event-handlers",
	Short: TRCLI("cli.event-handlers.summary"),
	Long:  TRCLI(`cli.event-handlers.description`),
}

var EventHandlersCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TRAPI("/event_handlers:post:summary"),
	Long:  TRAPI(`/event_handlers:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectEventHandlersCreateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var EventHandlersCreateCmdBody string

var EventHandlersCreateCmdDescription string

var EventHandlersCreateCmdName string

var EventHandlersCreateCmdStatus string

var EventHandlersCreateCmdTargetGroupId string

var EventHandlersCreateCmdTargetImsi string

var EventHandlersCreateCmdTargetOperatorId string

var EventHandlersCreateCmdTargetSimId string

var EventHandlersDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TRAPI("/event_handlers/{handler_id}:delete:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectEventHandlersDeleteCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var EventHandlersDeleteCmdHandlerId string

var EventHandlersGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/event_handlers/{handler_id}:get:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectEventHandlersGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var EventHandlersGetCmdHandlerId string

var EventHandlersIgnoreCmd = &cobra.Command{
	Use:   "ignore",
	Short: TRAPI("/event_handlers/{handler_id}/subscribers/{imsi}/ignore:post:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}/subscribers/{imsi}/ignore:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectEventHandlersIgnoreCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var EventHandlersIgnoreCmdHandlerId string

var EventHandlersIgnoreCmdImsi string

var EventHandlersListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/event_handlers:get:summary"),
	Long:  TRAPI(`/event_handlers:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectEventHandlersListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var EventHandlersListCmdTarget string

var EventHandlersListForSubscriberCmd = &cobra.Command{
	Use:   "list-for-subscriber",
	Short: TRAPI("/event_handlers/subscribers/{imsi}:get:summary"),
	Long:  TRAPI(`/event_handlers/subscribers/{imsi}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectEventHandlersListForSubscriberCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var EventHandlersListForSubscriberCmdImsi string

var EventHandlersUnignoreCmd = &cobra.Command{
	Use:   "unignore",
	Short: TRAPI("/event_handlers/{handler_id}/subscribers/{imsi}/ignore:delete:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}/subscribers/{imsi}/ignore:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectEventHandlersUnignoreCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var EventHandlersUnignoreCmdHandlerId string

var EventHandlersUnignoreCmdImsi string

var EventHandlersUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TRAPI("/event_handlers/{handler_id}:put:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectEventHandlersUpdateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var EventHandlersUpdateCmdBody string

var EventHandlersUpdateCmdHandlerId string

var FilesCmd = &cobra.Command{
	Use:   "files",
	Short: TRCLI("cli.files.summary"),
	Long:  TRCLI(`cli.files.description`),
}

var FilesDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TRAPI("/files/{scope}/{path}:delete:summary"),
	Long:  TRAPI(`/files/{scope}/{path}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectFilesDeleteCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var FilesDeleteCmdPath string

var FilesDeleteCmdScope string

var FilesDeleteDirectoryCmd = &cobra.Command{
	Use:   "delete-directory",
	Short: TRAPI("/files/{scope}/{path}/:delete:summary"),
	Long:  TRAPI(`/files/{scope}/{path}/:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectFilesDeleteDirectoryCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var FilesDeleteDirectoryCmdPath string

var FilesDeleteDirectoryCmdScope string

var FilesGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/files/{scope}/{path}:get:summary"),
	Long:  TRAPI(`/files/{scope}/{path}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectFilesGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}
		rawOutput = true

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var FilesGetCmdPath string

var FilesGetCmdScope string

var FilesGetExportedCmd = &cobra.Command{
	Use:   "get-exported",
	Short: TRAPI("/files/exported/{exported_file_id}:get:summary"),
	Long:  TRAPI(`/files/exported/{exported_file_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectFilesGetExportedCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var FilesGetExportedCmdExportedFileId string

var FilesGetMetadataCmd = &cobra.Command{
	Use:   "get-metadata",
	Short: TRAPI("/files/{scope}/{path}:head:summary"),
	Long:  TRAPI(`/files/{scope}/{path}:head:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectFilesGetMetadataCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var FilesGetMetadataCmdPath string

var FilesGetMetadataCmdScope string

var FilesListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/files/{scope}/{path}/:get:summary"),
	Long:  TRAPI(`/files/{scope}/{path}/:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectFilesListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var FilesListCmdLimit string

var FilesListCmdPath string

var FilesListCmdScope string

var FilesPutCmd = &cobra.Command{
	Use:   "put",
	Short: TRAPI("/files/{scope}/{path}:put:summary"),
	Long:  TRAPI(`/files/{scope}/{path}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectFilesPutCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var FilesPutCmdBody string

var FilesPutCmdContentType string

var FilesPutCmdPath string

var FilesPutCmdScope string

var GadgetsCmd = &cobra.Command{
	Use:   "gadgets",
	Short: TRCLI("cli.gadgets.summary"),
	Long:  TRCLI(`cli.gadgets.description`),
}

var GadgetsDeleteTagCmd = &cobra.Command{
	Use:   "delete-tag",
	Short: TRAPI("/gadgets/{product_id}/{serial_number}/tags/{tag_name}:delete:summary"),
	Long:  TRAPI(`/gadgets/{product_id}/{serial_number}/tags/{tag_name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsDeleteTagCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsDeleteTagCmdProductId string

var GadgetsDeleteTagCmdSerialNumber string

var GadgetsDeleteTagCmdTagName string

var GadgetsDisableTerminationCmd = &cobra.Command{
	Use:   "disable-termination",
	Short: TRAPI("/gadgets/{product_id}/{serial_number}/disable_termination:post:summary"),
	Long:  TRAPI(`/gadgets/{product_id}/{serial_number}/disable_termination:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsDisableTerminationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsDisableTerminationCmdProductId string

var GadgetsDisableTerminationCmdSerialNumber string

var GadgetsEnableTerminationCmd = &cobra.Command{
	Use:   "enable-termination",
	Short: TRAPI("/gadgets/{product_id}/{serial_number}/enable_termination:post:summary"),
	Long:  TRAPI(`/gadgets/{product_id}/{serial_number}/enable_termination:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsEnableTerminationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsEnableTerminationCmdProductId string

var GadgetsEnableTerminationCmdSerialNumber string

var GadgetsGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/gadgets/{product_id}/{serial_number}:get:summary"),
	Long:  TRAPI(`/gadgets/{product_id}/{serial_number}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsGetCmdProductId string

var GadgetsGetCmdSerialNumber string

var GadgetsListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/gadgets:get:summary"),
	Long:  TRAPI(`/gadgets:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsListCmdLastEvaluatedKey string

var GadgetsListCmdLimit int64

var GadgetsListCmdPaginate bool

var GadgetsListCmdProductId string

var GadgetsListCmdTagName string

var GadgetsListCmdTagValue string

var GadgetsListCmdTagValueMatchMode string

var GadgetsPutTagsCmd = &cobra.Command{
	Use:   "put-tags",
	Short: TRAPI("/gadgets/{product_id}/{serial_number}/tags:put:summary"),
	Long:  TRAPI(`/gadgets/{product_id}/{serial_number}/tags:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsPutTagsCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsPutTagsCmdBody string

var GadgetsPutTagsCmdProductId string

var GadgetsPutTagsCmdSerialNumber string

var GadgetsRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TRAPI("/gadgets/{product_id}/{serial_number}/register:post:summary"),
	Long:  TRAPI(`/gadgets/{product_id}/{serial_number}/register:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsRegisterCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsRegisterCmdBody string

var GadgetsRegisterCmdProductId string

var GadgetsRegisterCmdSerialNumber string

var GadgetsSetGroupCmd = &cobra.Command{
	Use:   "set-group",
	Short: TRAPI("/gadgets/{product_id}/{serial_number}/set_group:post:summary"),
	Long:  TRAPI(`/gadgets/{product_id}/{serial_number}/set_group:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsSetGroupCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsSetGroupCmdBody string

var GadgetsSetGroupCmdCreatedTime int64

var GadgetsSetGroupCmdGroupId string

var GadgetsSetGroupCmdLastModifiedTime int64

var GadgetsSetGroupCmdOperatorId string

var GadgetsSetGroupCmdProductId string

var GadgetsSetGroupCmdSerialNumber string

var GadgetsTerminateCmd = &cobra.Command{
	Use:   "terminate",
	Short: TRAPI("/gadgets/{product_id}/{serial_number}/terminate:post:summary"),
	Long:  TRAPI(`/gadgets/{product_id}/{serial_number}/terminate:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsTerminateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsTerminateCmdProductId string

var GadgetsTerminateCmdSerialNumber string

var GadgetsUnsetGroupCmd = &cobra.Command{
	Use:   "unset-group",
	Short: TRAPI("/gadgets/{product_id}/{serial_number}/unset_group:post:summary"),
	Long:  TRAPI(`/gadgets/{product_id}/{serial_number}/unset_group:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGadgetsUnsetGroupCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GadgetsUnsetGroupCmdProductId string

var GadgetsUnsetGroupCmdSerialNumber string

var GroupsCmd = &cobra.Command{
	Use:   "groups",
	Short: TRCLI("cli.groups.summary"),
	Long:  TRCLI(`cli.groups.description`),
}

var GroupsCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TRAPI("/groups:post:summary"),
	Long:  TRAPI(`/groups:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsCreateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsCreateCmdBody string

var GroupsDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TRAPI("/groups/{group_id}:delete:summary"),
	Long:  TRAPI(`/groups/{group_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsDeleteCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsDeleteCmdGroupId string

var GroupsDeleteConfigCmd = &cobra.Command{
	Use:   "delete-config",
	Short: TRAPI("/groups/{group_id}/configuration/{namespace}/{name}:delete:summary"),
	Long:  TRAPI(`/groups/{group_id}/configuration/{namespace}/{name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsDeleteConfigCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsDeleteConfigCmdGroupId string

var GroupsDeleteConfigCmdName string

var GroupsDeleteConfigCmdNamespace string

var GroupsDeleteConfigNamespaceCmd = &cobra.Command{
	Use:   "delete-config-namespace",
	Short: TRAPI("/groups/{group_id}/configuration/{namespace}:delete:summary"),
	Long:  TRAPI(`/groups/{group_id}/configuration/{namespace}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsDeleteConfigNamespaceCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsDeleteConfigNamespaceCmdGroupId string

var GroupsDeleteConfigNamespaceCmdNamespace string

var GroupsDeleteTagCmd = &cobra.Command{
	Use:   "delete-tag",
	Short: TRAPI("/groups/{group_id}/tags/{tag_name}:delete:summary"),
	Long:  TRAPI(`/groups/{group_id}/tags/{tag_name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsDeleteTagCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsDeleteTagCmdGroupId string

var GroupsDeleteTagCmdTagName string

var GroupsGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/groups/{group_id}:get:summary"),
	Long:  TRAPI(`/groups/{group_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsGetCmdGroupId string

var GroupsListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/groups:get:summary"),
	Long:  TRAPI(`/groups:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsListCmdLastEvaluatedKey string

var GroupsListCmdLimit int64

var GroupsListCmdPaginate bool

var GroupsListCmdTagName string

var GroupsListCmdTagValue string

var GroupsListCmdTagValueMatchMode string

var GroupsListSubscribersCmd = &cobra.Command{
	Use:   "list-subscribers",
	Short: TRAPI("/groups/{group_id}/subscribers:get:summary"),
	Long:  TRAPI(`/groups/{group_id}/subscribers:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsListSubscribersCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsListSubscribersCmdGroupId string

var GroupsListSubscribersCmdLastEvaluatedKey string

var GroupsListSubscribersCmdLimit int64

var GroupsListSubscribersCmdPaginate bool

var GroupsPutConfigCmd = &cobra.Command{
	Use:   "put-config",
	Short: TRAPI("/groups/{group_id}/configuration/{namespace}:put:summary"),
	Long:  TRAPI(`/groups/{group_id}/configuration/{namespace}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsPutConfigCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsPutConfigCmdBody string

var GroupsPutConfigCmdGroupId string

var GroupsPutConfigCmdNamespace string

var GroupsPutTagsCmd = &cobra.Command{
	Use:   "put-tags",
	Short: TRAPI("/groups/{group_id}/tags:put:summary"),
	Long:  TRAPI(`/groups/{group_id}/tags:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectGroupsPutTagsCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var GroupsPutTagsCmdBody string

var GroupsPutTagsCmdGroupId string

var LagoonCmd = &cobra.Command{
	Use:   "lagoon",
	Short: TRCLI("cli.lagoon.summary"),
	Long:  TRCLI(`cli.lagoon.description`),
}

var LagoonCreateUserCmd = &cobra.Command{
	Use:   "create-user",
	Short: TRAPI("/lagoon/users:post:summary"),
	Long:  TRAPI(`/lagoon/users:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonCreateUserCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonCreateUserCmdBody string

var LagoonCreateUserCmdRole string

var LagoonCreateUserCmdUserEmail string

var LagoonCreateUserCmdUserPassword string

var LagoonDashboardsCmd = &cobra.Command{
	Use:   "dashboards",
	Short: TRCLI("cli.lagoon.dashboards.summary"),
	Long:  TRCLI(`cli.lagoon.dashboards.description`),
}

var LagoonDashboardsInitPermissionsCmd = &cobra.Command{
	Use:   "init-permissions",
	Short: TRAPI("/lagoon/dashboards/{dashboard_id}/permissions/init:post:summary"),
	Long:  TRAPI(`/lagoon/dashboards/{dashboard_id}/permissions/init:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectLagoonDashboardsInitPermissionsCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonDashboardsInitPermissionsCmdDashboardId int64

var LagoonDashboardsListPermissionsCmd = &cobra.Command{
	Use:   "list-permissions",
	Short: TRAPI("/lagoon/dashboards/permission:get:summary"),
	Long:  TRAPI(`/lagoon/dashboards/permission:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonDashboardsListPermissionsCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonDashboardsUpdatePermissionsCmd = &cobra.Command{
	Use:   "update-permissions",
	Short: TRAPI("/lagoon/dashboards/{dashboard_id}/permissions:put:summary"),
	Long:  TRAPI(`/lagoon/dashboards/{dashboard_id}/permissions:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectLagoonDashboardsUpdatePermissionsCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonDashboardsUpdatePermissionsCmdBody string

var LagoonDashboardsUpdatePermissionsCmdDashboardId int64

var LagoonDeleteUserCmd = &cobra.Command{
	Use:   "delete-user",
	Short: TRAPI("/lagoon/users/{lagoon_user_id}:delete:summary"),
	Long:  TRAPI(`/lagoon/users/{lagoon_user_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonDeleteUserCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonDeleteUserCmdLagoonUserId int64

var LagoonGetImageLinkCmd = &cobra.Command{
	Use:   "get-image-link",
	Short: TRAPI("/lagoon/image/link:get:summary"),
	Long:  TRAPI(`/lagoon/image/link:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectLagoonGetImageLinkCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonLicensePacksCmd = &cobra.Command{
	Use:   "license-packs",
	Short: TRCLI("cli.lagoon.license-packs.summary"),
	Long:  TRCLI(`cli.lagoon.license-packs.description`),
}

var LagoonLicensePacksListStatusCmd = &cobra.Command{
	Use:   "list-status",
	Short: TRAPI("/lagoon/license_packs:get:summary"),
	Long:  TRAPI(`/lagoon/license_packs:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectLagoonLicensePacksListStatusCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonLicensePacksUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TRAPI("/lagoon/license_packs:put:summary"),
	Long:  TRAPI(`/lagoon/license_packs:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectLagoonLicensePacksUpdateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonLicensePacksUpdateCmdBody string

var LagoonListUsersCmd = &cobra.Command{
	Use:   "list-users",
	Short: TRAPI("/lagoon/users:get:summary"),
	Long:  TRAPI(`/lagoon/users:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonListUsersCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TRAPI("/lagoon/register:post:summary"),
	Long:  TRAPI(`/lagoon/register:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonRegisterCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonRegisterCmdBody string

var LagoonRegisterCmdPlan string

var LagoonRegisterCmdUserPassword string

var LagoonTerminateCmd = &cobra.Command{
	Use:   "terminate",
	Short: TRAPI("/lagoon/terminate:post:summary"),
	Long:  TRAPI(`/lagoon/terminate:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonTerminateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUpdateUserEmailCmd = &cobra.Command{
	Use:   "update-user-email",
	Short: TRAPI("/lagoon/users/{lagoon_user_id}/email:put:summary"),
	Long:  TRAPI(`/lagoon/users/{lagoon_user_id}/email:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonUpdateUserEmailCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUpdateUserEmailCmdBody string

var LagoonUpdateUserEmailCmdLagoonUserId int64

var LagoonUpdateUserEmailCmdUserEmail string

var LagoonUpdateUserPasswordCmd = &cobra.Command{
	Use:   "update-user-password",
	Short: TRAPI("/lagoon/users/{lagoon_user_id}/password:put:summary"),
	Long:  TRAPI(`/lagoon/users/{lagoon_user_id}/password:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonUpdateUserPasswordCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUpdateUserPasswordCmdBody string

var LagoonUpdateUserPasswordCmdLagoonUserId int64

var LagoonUpdateUserPasswordCmdNewPassword string

var LagoonUpdateUserPasswordCmdOldPassword string

var LagoonUpdateUserPasswordCmdUserEmail string

var LagoonUpdateUserPermissionCmd = &cobra.Command{
	Use:   "update-user-permission",
	Short: TRAPI("/lagoon/users/{lagoon_user_id}/permission:put:summary"),
	Long:  TRAPI(`/lagoon/users/{lagoon_user_id}/permission:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonUpdateUserPermissionCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUpdateUserPermissionCmdBody string

var LagoonUpdateUserPermissionCmdLagoonUserId int64

var LagoonUpdateUserPermissionCmdRole string

var LagoonUpdatedPlanCmd = &cobra.Command{
	Use:   "updated-plan",
	Short: TRAPI("/lagoon/plan:put:summary"),
	Long:  TRAPI(`/lagoon/plan:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectLagoonUpdatedPlanCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUpdatedPlanCmdBody string

var LagoonUpdatedPlanCmdPlan string

var LagoonUsersCmd = &cobra.Command{
	Use:   "users",
	Short: TRCLI("cli.lagoon.users.summary"),
	Long:  TRCLI(`cli.lagoon.users.description`),
}

var LagoonUsersCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TRAPI("/lagoon/users:post:summary"),
	Long:  TRAPI(`/lagoon/users:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonUsersCreateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUsersCreateCmdBody string

var LagoonUsersCreateCmdRole string

var LagoonUsersCreateCmdUserEmail string

var LagoonUsersCreateCmdUserPassword string

var LagoonUsersDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TRAPI("/lagoon/users/{lagoon_user_id}:delete:summary"),
	Long:  TRAPI(`/lagoon/users/{lagoon_user_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonUsersDeleteCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUsersDeleteCmdLagoonUserId int64

var LagoonUsersListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/lagoon/users:get:summary"),
	Long:  TRAPI(`/lagoon/users:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonUsersListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUsersUpdateEmailCmd = &cobra.Command{
	Use:   "update-email",
	Short: TRAPI("/lagoon/users/{lagoon_user_id}/email:put:summary"),
	Long:  TRAPI(`/lagoon/users/{lagoon_user_id}/email:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonUsersUpdateEmailCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUsersUpdateEmailCmdBody string

var LagoonUsersUpdateEmailCmdLagoonUserId int64

var LagoonUsersUpdateEmailCmdUserEmail string

var LagoonUsersUpdatePasswordCmd = &cobra.Command{
	Use:   "update-password",
	Short: TRAPI("/lagoon/users/{lagoon_user_id}/password:put:summary"),
	Long:  TRAPI(`/lagoon/users/{lagoon_user_id}/password:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonUsersUpdatePasswordCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUsersUpdatePasswordCmdBody string

var LagoonUsersUpdatePasswordCmdLagoonUserId int64

var LagoonUsersUpdatePasswordCmdNewPassword string

var LagoonUsersUpdatePasswordCmdOldPassword string

var LagoonUsersUpdatePasswordCmdUserEmail string

var LagoonUsersUpdatePermissionCmd = &cobra.Command{
	Use:   "update-permission",
	Short: TRAPI("/lagoon/users/{lagoon_user_id}/permission:put:summary"),
	Long:  TRAPI(`/lagoon/users/{lagoon_user_id}/permission:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLagoonUsersUpdatePermissionCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LagoonUsersUpdatePermissionCmdBody string

var LagoonUsersUpdatePermissionCmdLagoonUserId int64

var LagoonUsersUpdatePermissionCmdRole string

var LogsCmd = &cobra.Command{
	Use:   "logs",
	Short: TRCLI("cli.logs.summary"),
	Long:  TRCLI(`cli.logs.description`),
}

var LogsGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/logs:get:summary"),
	Long:  TRAPI(`/logs:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLogsGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LogsGetCmdFrom int64

var LogsGetCmdLastEvaluatedKey string

var LogsGetCmdLimit int64

var LogsGetCmdPaginate bool

var LogsGetCmdResourceId string

var LogsGetCmdResourceType string

var LogsGetCmdService string

var LogsGetCmdTo int64

var LoraDevicesCmd = &cobra.Command{
	Use:   "lora-devices",
	Short: TRCLI("cli.lora-devices.summary"),
	Long:  TRCLI(`cli.lora-devices.description`),
}

var LoraDevicesDeleteTagCmd = &cobra.Command{
	Use:   "delete-tag",
	Short: TRAPI("/lora_devices/{device_id}/tags/{tag_name}:delete:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/tags/{tag_name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesDeleteTagCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesDeleteTagCmdDeviceId string

var LoraDevicesDeleteTagCmdTagName string

var LoraDevicesDisableTerminationCmd = &cobra.Command{
	Use:   "disable-termination",
	Short: TRAPI("/lora_devices/{device_id}/disable_termination:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/disable_termination:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesDisableTerminationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesDisableTerminationCmdDeviceId string

var LoraDevicesEnableTerminationCmd = &cobra.Command{
	Use:   "enable-termination",
	Short: TRAPI("/lora_devices/{device_id}/enable_termination:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/enable_termination:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesEnableTerminationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesEnableTerminationCmdDeviceId string

var LoraDevicesGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/lora_devices/{device_id}:get:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesGetCmdDeviceId string

var LoraDevicesGetDataCmd = &cobra.Command{
	Use:   "get-data",
	Short: TRAPI("/lora_devices/{device_id}/data:get:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/data:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesGetDataCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesGetDataCmdDeviceId string

var LoraDevicesGetDataCmdFrom int64

var LoraDevicesGetDataCmdLastEvaluatedKey string

var LoraDevicesGetDataCmdLimit int64

var LoraDevicesGetDataCmdPaginate bool

var LoraDevicesGetDataCmdSort string

var LoraDevicesGetDataCmdTo int64

var LoraDevicesListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/lora_devices:get:summary"),
	Long:  TRAPI(`/lora_devices:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesListCmdLastEvaluatedKey string

var LoraDevicesListCmdLimit int64

var LoraDevicesListCmdPaginate bool

var LoraDevicesListCmdTagName string

var LoraDevicesListCmdTagValue string

var LoraDevicesListCmdTagValueMatchMode string

var LoraDevicesPutTagsCmd = &cobra.Command{
	Use:   "put-tags",
	Short: TRAPI("/lora_devices/{device_id}/tags:put:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/tags:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesPutTagsCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesPutTagsCmdBody string

var LoraDevicesPutTagsCmdDeviceId string

var LoraDevicesRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TRAPI("/lora_devices/{device_id}/register:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/register:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesRegisterCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesRegisterCmdBody string

var LoraDevicesRegisterCmdDeviceId string

var LoraDevicesRegisterCmdGroupId string

var LoraDevicesRegisterCmdRegistrationSecret string

var LoraDevicesSendDataCmd = &cobra.Command{
	Use:   "send-data",
	Short: TRAPI("/lora_devices/{device_id}/data:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/data:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesSendDataCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesSendDataCmdBody string

var LoraDevicesSendDataCmdData string

var LoraDevicesSendDataCmdDeviceId string

var LoraDevicesSendDataCmdFPort int64

var LoraDevicesSetGroupCmd = &cobra.Command{
	Use:   "set-group",
	Short: TRAPI("/lora_devices/{device_id}/set_group:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/set_group:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesSetGroupCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesSetGroupCmdBody string

var LoraDevicesSetGroupCmdCreatedTime int64

var LoraDevicesSetGroupCmdDeviceId string

var LoraDevicesSetGroupCmdGroupId string

var LoraDevicesSetGroupCmdLastModifiedTime int64

var LoraDevicesSetGroupCmdOperatorId string

var LoraDevicesTerminateCmd = &cobra.Command{
	Use:   "terminate",
	Short: TRAPI("/lora_devices/{device_id}/terminate:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/terminate:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesTerminateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesTerminateCmdDeviceId string

var LoraDevicesUnsetGroupCmd = &cobra.Command{
	Use:   "unset-group",
	Short: TRAPI("/lora_devices/{device_id}/unset_group:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/unset_group:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraDevicesUnsetGroupCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraDevicesUnsetGroupCmdDeviceId string

var LoraGatewaysCmd = &cobra.Command{
	Use:   "lora-gateways",
	Short: TRCLI("cli.lora-gateways.summary"),
	Long:  TRCLI(`cli.lora-gateways.description`),
}

var LoraGatewaysDeleteTagCmd = &cobra.Command{
	Use:   "delete-tag",
	Short: TRAPI("/lora_gateways/{gateway_id}/tags/{tag_name}:delete:summary"),
	Long:  TRAPI(`/lora_gateways/{gateway_id}/tags/{tag_name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraGatewaysDeleteTagCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraGatewaysDeleteTagCmdGatewayId string

var LoraGatewaysDeleteTagCmdTagName string

var LoraGatewaysDisableTerminationCmd = &cobra.Command{
	Use:   "disable-termination",
	Short: TRAPI("/lora_gateways/{gateway_id}/disable_termination:post:summary"),
	Long:  TRAPI(`/lora_gateways/{gateway_id}/disable_termination:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraGatewaysDisableTerminationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraGatewaysDisableTerminationCmdGatewayId string

var LoraGatewaysEnableTerminationCmd = &cobra.Command{
	Use:   "enable-termination",
	Short: TRAPI("/lora_gateways/{gateway_id}/enable_termination:post:summary"),
	Long:  TRAPI(`/lora_gateways/{gateway_id}/enable_termination:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraGatewaysEnableTerminationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraGatewaysEnableTerminationCmdGatewayId string

var LoraGatewaysGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/lora_gateways/{gateway_id}:get:summary"),
	Long:  TRAPI(`/lora_gateways/{gateway_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraGatewaysGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraGatewaysGetCmdGatewayId string

var LoraGatewaysListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/lora_gateways:get:summary"),
	Long:  TRAPI(`/lora_gateways:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraGatewaysListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraGatewaysListCmdLastEvaluatedKey string

var LoraGatewaysListCmdLimit int64

var LoraGatewaysListCmdPaginate bool

var LoraGatewaysListCmdTagName string

var LoraGatewaysListCmdTagValue string

var LoraGatewaysListCmdTagValueMatchMode string

var LoraGatewaysPutTagsCmd = &cobra.Command{
	Use:   "put-tags",
	Short: TRAPI("/lora_gateways/{gateway_id}/tags:put:summary"),
	Long:  TRAPI(`/lora_gateways/{gateway_id}/tags:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraGatewaysPutTagsCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraGatewaysPutTagsCmdBody string

var LoraGatewaysPutTagsCmdGatewayId string

var LoraGatewaysSetNetworkSetCmd = &cobra.Command{
	Use:   "set-network-set",
	Short: TRAPI("/lora_gateways/{gateway_id}/set_network_set:post:summary"),
	Long:  TRAPI(`/lora_gateways/{gateway_id}/set_network_set:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraGatewaysSetNetworkSetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraGatewaysSetNetworkSetCmdBody string

var LoraGatewaysSetNetworkSetCmdGatewayId string

var LoraGatewaysSetNetworkSetCmdNetworkSetId string

var LoraGatewaysTerminateCmd = &cobra.Command{
	Use:   "terminate",
	Short: TRAPI("/lora_gateways/{gateway_id}/terminate:post:summary"),
	Long:  TRAPI(`/lora_gateways/{gateway_id}/terminate:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraGatewaysTerminateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraGatewaysTerminateCmdGatewayId string

var LoraGatewaysUnsetNetworkSetCmd = &cobra.Command{
	Use:   "unset-network-set",
	Short: TRAPI("/lora_gateways/{gateway_id}/unset_network_set:post:summary"),
	Long:  TRAPI(`/lora_gateways/{gateway_id}/unset_network_set:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraGatewaysUnsetNetworkSetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraGatewaysUnsetNetworkSetCmdGatewayId string

var LoraNetworkSetsAddPermissionCmd = &cobra.Command{
	Use:   "add-permission",
	Short: TRAPI("/lora_network_sets/{ns_id}/add_permission:post:summary"),
	Long:  TRAPI(`/lora_network_sets/{ns_id}/add_permission:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraNetworkSetsAddPermissionCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraNetworkSetsAddPermissionCmdBody string

var LoraNetworkSetsAddPermissionCmdNsId string

var LoraNetworkSetsAddPermissionCmdOperatorId string

var LoraNetworkSetsCmd = &cobra.Command{
	Use:   "lora-network-sets",
	Short: TRCLI("cli.lora-network-sets.summary"),
	Long:  TRCLI(`cli.lora-network-sets.description`),
}

var LoraNetworkSetsCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TRAPI("/lora_network_sets:post:summary"),
	Long:  TRAPI(`/lora_network_sets:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraNetworkSetsCreateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraNetworkSetsCreateCmdBody string

var LoraNetworkSetsCreateCmdCreatedTime string

var LoraNetworkSetsCreateCmdLastModifiedTime string

var LoraNetworkSetsCreateCmdNetworkSetId string

var LoraNetworkSetsCreateCmdOperatorId string

var LoraNetworkSetsDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TRAPI("/lora_network_sets/{ns_id}:delete:summary"),
	Long:  TRAPI(`/lora_network_sets/{ns_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraNetworkSetsDeleteCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraNetworkSetsDeleteCmdNsId string

var LoraNetworkSetsDeleteTagCmd = &cobra.Command{
	Use:   "delete-tag",
	Short: TRAPI("/lora_network_sets/{ns_id}/tags/{tag_name}:delete:summary"),
	Long:  TRAPI(`/lora_network_sets/{ns_id}/tags/{tag_name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraNetworkSetsDeleteTagCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraNetworkSetsDeleteTagCmdNsId string

var LoraNetworkSetsDeleteTagCmdTagName string

var LoraNetworkSetsGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/lora_network_sets/{ns_id}:get:summary"),
	Long:  TRAPI(`/lora_network_sets/{ns_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraNetworkSetsGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraNetworkSetsGetCmdNsId string

var LoraNetworkSetsListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/lora_network_sets:get:summary"),
	Long:  TRAPI(`/lora_network_sets:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraNetworkSetsListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraNetworkSetsListCmdLastEvaluatedKey string

var LoraNetworkSetsListCmdLimit int64

var LoraNetworkSetsListCmdPaginate bool

var LoraNetworkSetsListCmdTagName string

var LoraNetworkSetsListCmdTagValue string

var LoraNetworkSetsListCmdTagValueMatchMode string

var LoraNetworkSetsListGatewaysCmd = &cobra.Command{
	Use:   "list-gateways",
	Short: TRAPI("/lora_network_sets/{ns_id}/gateways:get:summary"),
	Long:  TRAPI(`/lora_network_sets/{ns_id}/gateways:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraNetworkSetsListGatewaysCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraNetworkSetsListGatewaysCmdLastEvaluatedKey string

var LoraNetworkSetsListGatewaysCmdLimit int64

var LoraNetworkSetsListGatewaysCmdNsId string

var LoraNetworkSetsListGatewaysCmdPaginate bool

var LoraNetworkSetsRevokePermissionCmd = &cobra.Command{
	Use:   "revoke-permission",
	Short: TRAPI("/lora_network_sets/{ns_id}/revoke_permission:post:summary"),
	Long:  TRAPI(`/lora_network_sets/{ns_id}/revoke_permission:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectLoraNetworkSetsRevokePermissionCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var LoraNetworkSetsRevokePermissionCmdBody string

var LoraNetworkSetsRevokePermissionCmdNsId string

var LoraNetworkSetsRevokePermissionCmdOperatorId string

var OperatorAddContractCmd = &cobra.Command{
	Use:   "add-contract",
	Short: TRAPI("/operators/{operator_id}/contracts:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/contracts:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorAddContractCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorAddContractCmdBody string

var OperatorAddContractCmdContractName string

var OperatorAddContractCmdOperatorId string

var OperatorAddCoverageTypeCmd = &cobra.Command{
	Use:   "add-coverage-type",
	Short: TRAPI("/operators/{operator_id}/coverage_type/{coverage_type}:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/coverage_type/{coverage_type}:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorAddCoverageTypeCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorAddCoverageTypeCmdCoverageType string

var OperatorAddCoverageTypeCmdOperatorId string

var OperatorAuthKeysCmd = &cobra.Command{
	Use:   "auth-keys",
	Short: TRCLI("cli.operator.auth-keys.summary"),
	Long:  TRCLI(`cli.operator.auth-keys.description`),
}

var OperatorAuthKeysDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TRAPI("/operators/{operator_id}/auth_keys/{auth_key_id}:delete:summary"),
	Long:  TRAPI(`/operators/{operator_id}/auth_keys/{auth_key_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorAuthKeysDeleteCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorAuthKeysDeleteCmdAuthKeyId string

var OperatorAuthKeysDeleteCmdOperatorId string

var OperatorAuthKeysGenerateCmd = &cobra.Command{
	Use:   "generate",
	Short: TRAPI("/operators/{operator_id}/auth_keys:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/auth_keys:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorAuthKeysGenerateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorAuthKeysGenerateCmdOperatorId string

var OperatorAuthKeysListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/operators/{operator_id}/auth_keys:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/auth_keys:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorAuthKeysListCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorAuthKeysListCmdOperatorId string

var OperatorCmd = &cobra.Command{
	Use:   "operator",
	Short: TRCLI("cli.operator.summary"),
	Long:  TRCLI(`cli.operator.description`),
}

var OperatorCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TRAPI("/operators:post:summary"),
	Long:  TRAPI(`/operators:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorCreateCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorCreateCmdBody string

var OperatorCreateCmdEmail string

var OperatorCreateCmdPassword string

var OperatorCreateCompanyInformationCmd = &cobra.Command{
	Use:   "create-company-information",
	Short: TRAPI("/operators/{operator_id}/company_information:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/company_information:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorCreateCompanyInformationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorCreateCompanyInformationCmdAddressLine1 string

var OperatorCreateCompanyInformationCmdAddressLine2 string

var OperatorCreateCompanyInformationCmdBody string

var OperatorCreateCompanyInformationCmdBuilding string

var OperatorCreateCompanyInformationCmdCity string

var OperatorCreateCompanyInformationCmdCompanyName string

var OperatorCreateCompanyInformationCmdContactPersonName string

var OperatorCreateCompanyInformationCmdCountryCode string

var OperatorCreateCompanyInformationCmdDepartment string

var OperatorCreateCompanyInformationCmdOperatorId string

var OperatorCreateCompanyInformationCmdPhoneNumber string

var OperatorCreateCompanyInformationCmdState string

var OperatorCreateCompanyInformationCmdVatIdentificationNumber string

var OperatorCreateCompanyInformationCmdZipCode string

var OperatorCreateIndividualInformationCmd = &cobra.Command{
	Use:   "create-individual-information",
	Short: TRAPI("/operators/{operator_id}/individual_information:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/individual_information:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorCreateIndividualInformationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorCreateIndividualInformationCmdAddressLine1 string

var OperatorCreateIndividualInformationCmdAddressLine2 string

var OperatorCreateIndividualInformationCmdBody string

var OperatorCreateIndividualInformationCmdBuilding string

var OperatorCreateIndividualInformationCmdCity string

var OperatorCreateIndividualInformationCmdCountryCode string

var OperatorCreateIndividualInformationCmdFullName string

var OperatorCreateIndividualInformationCmdOperatorId string

var OperatorCreateIndividualInformationCmdPhoneNumber string

var OperatorCreateIndividualInformationCmdState string

var OperatorCreateIndividualInformationCmdZipCode string

var OperatorDeleteContractCmd = &cobra.Command{
	Use:   "delete-contract",
	Short: TRAPI("/operators/{operator_id}/contracts/{contract_name}:delete:summary"),
	Long:  TRAPI(`/operators/{operator_id}/contracts/{contract_name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorDeleteContractCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorDeleteContractCmdContractName string

var OperatorDeleteContractCmdOperatorId string

var OperatorEnableMfaCmd = &cobra.Command{
	Use:   "enable-mfa",
	Short: TRAPI("/operators/{operator_id}/mfa:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/mfa:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorEnableMfaCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorEnableMfaCmdOperatorId string

var OperatorGenerateApiTokenCmd = &cobra.Command{
	Use:   "generate-api-token",
	Short: TRAPI("/operators/{operator_id}/token:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/token:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorGenerateApiTokenCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorGenerateApiTokenCmdBody string

var OperatorGenerateApiTokenCmdOperatorId string

var OperatorGenerateApiTokenCmdTokenTimeoutSeconds int64

var OperatorGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/operators/{operator_id}:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorGetCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorGetCmdOperatorId string

var OperatorGetCompanyInformationCmd = &cobra.Command{
	Use:   "get-company-information",
	Short: TRAPI("/operators/{operator_id}/company_information:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/company_information:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorGetCompanyInformationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorGetCompanyInformationCmdOperatorId string

var OperatorGetIndividualInformationCmd = &cobra.Command{
	Use:   "get-individual-information",
	Short: TRAPI("/operators/{operator_id}/individual_information:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/individual_information:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorGetIndividualInformationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorGetIndividualInformationCmdOperatorId string

var OperatorGetMfaStatusCmd = &cobra.Command{
	Use:   "get-mfa-status",
	Short: TRAPI("/operators/{operator_id}/mfa:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/mfa:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorGetMfaStatusCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorGetMfaStatusCmdOperatorId string

var OperatorGetSupportTokenCmd = &cobra.Command{
	Use:   "get-support-token",
	Short: TRAPI("/operators/{operator_id}/support/token:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/support/token:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorGetSupportTokenCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorGetSupportTokenCmdOperatorId string

var OperatorIssueEmailChangeTokenCmd = &cobra.Command{
	Use:   "issue-email-change-token",
	Short: TRAPI("/operators/email_change_token/issue:post:summary"),
	Long:  TRAPI(`/operators/email_change_token/issue:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorIssueEmailChangeTokenCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorIssueEmailChangeTokenCmdBody string

var OperatorIssueEmailChangeTokenCmdEmail string

var OperatorIssueMfaRevokeTokenCmd = &cobra.Command{
	Use:   "issue-mfa-revoke-token",
	Short: TRAPI("/operators/mfa_revoke_token/issue:post:summary"),
	Long:  TRAPI(`/operators/mfa_revoke_token/issue:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}

		param, err := collectOperatorIssueMfaRevokeTokenCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorIssueMfaRevokeTokenCmdBody string

var OperatorIssueMfaRevokeTokenCmdEmail string

var OperatorIssueMfaRevokeTokenCmdPassword string

var OperatorRevokeMfaCmd = &cobra.Command{
	Use:   "revoke-mfa",
	Short: TRAPI("/operators/{operator_id}/mfa:delete:summary"),
	Long:  TRAPI(`/operators/{operator_id}/mfa:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorRevokeMfaCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorRevokeMfaCmdOperatorId string

var OperatorUpdateCompanyInformationCmd = &cobra.Command{
	Use:   "update-company-information",
	Short: TRAPI("/operators/{operator_id}/company_information:put:summary"),
	Long:  TRAPI(`/operators/{operator_id}/company_information:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorUpdateCompanyInformationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorUpdateCompanyInformationCmdAddressLine1 string

var OperatorUpdateCompanyInformationCmdAddressLine2 string

var OperatorUpdateCompanyInformationCmdBody string

var OperatorUpdateCompanyInformationCmdBuilding string

var OperatorUpdateCompanyInformationCmdCity string

var OperatorUpdateCompanyInformationCmdCompanyName string

var OperatorUpdateCompanyInformationCmdContactPersonName string

var OperatorUpdateCompanyInformationCmdCountryCode string

var OperatorUpdateCompanyInformationCmdDepartment string

var OperatorUpdateCompanyInformationCmdOperatorId string

var OperatorUpdateCompanyInformationCmdPhoneNumber string

var OperatorUpdateCompanyInformationCmdState string

var OperatorUpdateCompanyInformationCmdVatIdentificationNumber string

var OperatorUpdateCompanyInformationCmdZipCode string

var OperatorUpdateIndividualInformationCmd = &cobra.Command{
	Use:   "update-individual-information",
	Short: TRAPI("/operators/{operator_id}/individual_information:put:summary"),
	Long:  TRAPI(`/operators/{operator_id}/individual_information:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorUpdateIndividualInformationCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}

var OperatorUpdateIndividualInformationCmdAddressLine1 string

var OperatorUpdateIndividualInformationCmdAddressLine2 string

var OperatorUpdateIndividualInformationCmdBody string

var OperatorUpdateIndividualInformationCmdBuilding string

var OperatorUpdateIndividualInformationCmdCity string

var OperatorUpdateIndividualInformationCmdCountryCode string

var OperatorUpdateIndividualInformationCmdFullName string

var OperatorUpdateIndividualInformationCmdOperatorId string

var OperatorUpdateIndividualInformationCmdPhoneNumber string

var OperatorUpdateIndividualInformationCmdState string

var OperatorUpdateIndividualInformationCmdZipCode string

var OperatorUpdatePasswordCmd = &cobra.Command{
	Use:   "update-password",
	Short: TRAPI("/operators/{operator_id}/password:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/password:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

		ac := newAPIClient(opt)
		if v := os.Getenv("SORACOM_VERBOSE"); v != "" {
			ac.SetVerbose(true)
		}
		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorUpdatePasswordCmdParams(ac)
		if err != nil {
			return err
		}

		body, err := ac.callAPI(param)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		if body == "" {
			return nil
		}

		if rawOutput {
			_, err = os.Stdout.Write([]byte(body))
		} else {
			return prettyPrintStringAsJSON(body)
		}
		return err
	},
}