cmd

var AuthCmd = &cobra.Command{
	Use:   "auth",
	Short: TR("auth.auth.post.summary"),
	Long:  TR(`auth.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var AuthCmdAuthKey string

var AuthCmdAuthKeyId string

var AuthCmdBody string

var AuthCmdEmail string

var AuthCmdOperatorId string

var AuthCmdPassword string

var AuthCmdTokenTimeoutSeconds int64

var AuthCmdUserName string

var AuthIssuePasswordResetTokenCmd = &cobra.Command{
	Use:   "issue-password-reset-token",
	Short: TR("auth.issue_password_reset_token.post.summary"),
	Long:  TR(`auth.issue_password_reset_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)
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var AuthIssuePasswordResetTokenCmdBody string

var AuthIssuePasswordResetTokenCmdEmail string

var AuthVerifyPasswordResetTokenCmd = &cobra.Command{
	Use:   "verify-password-reset-token",
	Short: TR("auth.verify_password_reset_token.post.summary"),
	Long:  TR(`auth.verify_password_reset_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)
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var AuthVerifyPasswordResetTokenCmdBody string

var AuthVerifyPasswordResetTokenCmdPassword string

var AuthVerifyPasswordResetTokenCmdToken string

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

var BillsExportCmd = &cobra.Command{
	Use:   "export",
	Short: TR("bills.export_billing.post.summary"),
	Long:  TR(`bills.export_billing.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var BillsExportCmdExportMode string

var BillsExportCmdYyyyMM string

var BillsExportLatestCmd = &cobra.Command{
	Use:   "export-latest",
	Short: TR("bills.export_latest_billing.post.summary"),
	Long:  TR(`bills.export_latest_billing.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var BillsExportLatestCmdExportMode string

var BillsGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("bills.get_billing.get.summary"),
	Long:  TR(`bills.get_billing.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var BillsGetCmdYyyyMM string

var BillsGetDailyCmd = &cobra.Command{
	Use:   "get-daily",
	Short: TR("bills.get_billing_per_day.get.summary"),
	Long:  TR(`bills.get_billing_per_day.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var BillsGetDailyCmdYyyyMM string

var BillsGetLatestCmd = &cobra.Command{
	Use:   "get-latest",
	Short: TR("bills.get_latest_billing.get.summary"),
	Long:  TR(`bills.get_latest_billing.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var BillsListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("bills.get_billing_history.get.summary"),
	Long:  TR(`bills.get_billing_history.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

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

var ConfigureCmd = &cobra.Command{
	Use:   "configure",
	Short: TR("configure.cli.summary"),
	Long:  TR("configure.cli.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: TR("configure.get.cli.summary"),
	Long:  TR("configure.get.cli.description"),
	RunE: func(cmd *cobra.Command, args []string) error {
		pn := getSpecifiedProfileName()
		if pn == "" {
			pn = "default"
		}

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

		prettyPrintObjectAsJSON(p)
		return nil
	},
}

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

var CouponsListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("payment.list_coupons.get.summary"),
	Long:  TR(`payment.list_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var CouponsRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TR("payment.register_coupon.post.summary"),
	Long:  TR(`payment.register_coupon.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var CouponsRegisterCmdCouponCode string

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

var CredentialsCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("credentials.create_credential.post.summary"),
	Long:  TR(`credentials.create_credential.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var CredentialsCreateCmdBody string

var CredentialsCreateCmdCredentialsId string

var CredentialsCreateCmdDescription string

var CredentialsCreateCmdType string

var CredentialsDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TR("credentials.delete_credential.delete.summary"),
	Long:  TR(`credentials.delete_credential.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var CredentialsDeleteCmdCredentialsId string

var CredentialsListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("credentials.list_credentials.get.summary"),
	Long:  TR(`credentials.list_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var CredentialsUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TR("credentials.update_credential.put.summary"),
	Long:  TR(`credentials.update_credential.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var CredentialsUpdateCmdBody string

var CredentialsUpdateCmdCredentialsId string

var CredentialsUpdateCmdDescription string

var CredentialsUpdateCmdType string

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

var DataGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("subscribers.get_data_from_subscriber.get.summary"),
	Long:  TR(`subscribers.get_data_from_subscriber.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DataGetCmdFrom int64

var DataGetCmdImsi string

var DataGetCmdLastEvaluatedKey string

var DataGetCmdLimit int64

var DataGetCmdSort string

var DataGetCmdTo int64

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

var EventHandlersCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("event_handlers.create_event_handler.post.summary"),
	Long:  TR(`event_handlers.create_event_handler.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var EventHandlersCreateCmdBody string

var EventHandlersCreateCmdDescription string

var EventHandlersCreateCmdName string

var EventHandlersCreateCmdStatus string

var EventHandlersCreateCmdTargetGroupId string

var EventHandlersCreateCmdTargetImsi string

var EventHandlersCreateCmdTargetOperatorId string

var EventHandlersDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TR("event_handlers.delete_event_handler.delete.summary"),
	Long:  TR(`event_handlers.delete_event_handler.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var EventHandlersDeleteCmdHandlerId string

var EventHandlersGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("event_handlers.get_event_handler.get.summary"),
	Long:  TR(`event_handlers.get_event_handler.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var EventHandlersGetCmdHandlerId string

var EventHandlersIgnoreCmd = &cobra.Command{
	Use:   "ignore",
	Short: TR("event_handlers.set_ignore_event_handler.post.summary"),
	Long:  TR(`event_handlers.set_ignore_event_handler.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var EventHandlersIgnoreCmdHandlerId string

var EventHandlersIgnoreCmdImsi string

var EventHandlersListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("event_handlers.list_event_handlers.get.summary"),
	Long:  TR(`event_handlers.list_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var EventHandlersListCmdTarget string

var EventHandlersListForSubscriberCmd = &cobra.Command{
	Use:   "list-for-subscriber",
	Short: TR("event_handlers.list_event_handlers_by_subscriber.get.summary"),
	Long:  TR(`event_handlers.list_event_handlers_by_subscriber.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var EventHandlersListForSubscriberCmdImsi string

var EventHandlersUnignoreCmd = &cobra.Command{
	Use:   "unignore",
	Short: TR("event_handlers.delete_ignore_event_handler.delete.summary"),
	Long:  TR(`event_handlers.delete_ignore_event_handler.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var EventHandlersUnignoreCmdHandlerId string

var EventHandlersUnignoreCmdImsi string

var EventHandlersUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TR("event_handlers.update_event_handler.put.summary"),
	Long:  TR(`event_handlers.update_event_handler.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var EventHandlersUpdateCmdBody string

var EventHandlersUpdateCmdHandlerId string

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

var FilesGetExportedCmd = &cobra.Command{
	Use:   "get-exported",
	Short: TR("files.get_exported.get.summary"),
	Long:  TR(`files.get_exported.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var FilesGetExportedCmdExportedFileId string

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

var GroupsCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("groups.create_group.post.summary"),
	Long:  TR(`groups.create_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 := collectGroupsCreateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var GroupsCreateCmdBody string

var GroupsDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TR("groups.delete_group.delete.summary"),
	Long:  TR(`groups.delete_group.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var GroupsDeleteCmdGroupId string

var GroupsDeleteConfigCmd = &cobra.Command{
	Use:   "delete-config",
	Short: TR("groups.delete_configuration_parameter.delete.summary"),
	Long:  TR(`groups.delete_configuration_parameter.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var GroupsDeleteConfigCmdGroupId string

var GroupsDeleteConfigCmdName string

var GroupsDeleteConfigCmdNamespace string

var GroupsDeleteTagCmd = &cobra.Command{
	Use:   "delete-tag",
	Short: TR("groups.delete_group_tag.delete.summary"),
	Long:  TR(`groups.delete_group_tag.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var GroupsDeleteTagCmdGroupId string

var GroupsDeleteTagCmdTagName string

var GroupsGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("groups.get_group.get.summary"),
	Long:  TR(`groups.get_group.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var GroupsGetCmdGroupId string

var GroupsListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("groups.list_groups.get.summary"),
	Long:  TR(`groups.list_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var GroupsListCmdLastEvaluatedKey string

var GroupsListCmdLimit int64

var GroupsListCmdTagName string

var GroupsListCmdTagValue string

var GroupsListCmdTagValueMatchMode string

var GroupsListSubscribersCmd = &cobra.Command{
	Use:   "list-subscribers",
	Short: TR("groups.list_subscribers_in_group.get.summary"),
	Long:  TR(`groups.list_subscribers_in_group.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var GroupsListSubscribersCmdGroupId string

var GroupsListSubscribersCmdLastEvaluatedKey string

var GroupsListSubscribersCmdLimit int64

var GroupsPutConfigCmd = &cobra.Command{
	Use:   "put-config",
	Short: TR("groups.put_configuration_parameters.put.summary"),
	Long:  TR(`groups.put_configuration_parameters.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var GroupsPutConfigCmdBody string

var GroupsPutConfigCmdGroupId string

var GroupsPutConfigCmdNamespace string

var GroupsPutTagsCmd = &cobra.Command{
	Use:   "put-tags",
	Short: TR("groups.put_group_tags.put.summary"),
	Long:  TR(`groups.put_group_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var GroupsPutTagsCmdBody string

var GroupsPutTagsCmdGroupId string

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

var LogsGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("logs.get_logs.get.summary"),
	Long:  TR(`logs.get_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LogsGetCmdFrom int64

var LogsGetCmdLastEvaluatedKey string

var LogsGetCmdLimit int64

var LogsGetCmdResourceId string

var LogsGetCmdResourceType string

var LogsGetCmdService string

var LogsGetCmdTo int64

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

var LoraDevicesDeleteTagCmd = &cobra.Command{
	Use:   "delete-tag",
	Short: TR("lora_devices.delete_lora_device_tag.delete.summary"),
	Long:  TR(`lora_devices.delete_lora_device_tag.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesDeleteTagCmdDeviceId string

var LoraDevicesDeleteTagCmdTagName string

var LoraDevicesDisableTerminationCmd = &cobra.Command{
	Use:   "disable-termination",
	Short: TR("lora_devices.disable_termination.post.summary"),
	Long:  TR(`lora_devices.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesDisableTerminationCmdDeviceId string

var LoraDevicesEnableTerminationCmd = &cobra.Command{
	Use:   "enable-termination",
	Short: TR("lora_devices.enable_termination.post.summary"),
	Long:  TR(`lora_devices.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesEnableTerminationCmdDeviceId string

var LoraDevicesGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("lora_devices.get_lora_device.get.summary"),
	Long:  TR(`lora_devices.get_lora_device.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesGetCmdDeviceId string

var LoraDevicesGetDataCmd = &cobra.Command{
	Use:   "get-data",
	Short: TR("lora_devices.get_data_from_lora_device.get.summary"),
	Long:  TR(`lora_devices.get_data_from_lora_device.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesGetDataCmdDeviceId string

var LoraDevicesGetDataCmdFrom int64

var LoraDevicesGetDataCmdLastEvaluatedKey string

var LoraDevicesGetDataCmdLimit int64

var LoraDevicesGetDataCmdSort string

var LoraDevicesGetDataCmdTo int64

var LoraDevicesListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("lora_devices.list_lora_devices.get.summary"),
	Long:  TR(`lora_devices.list_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesListCmdLastEvaluatedKey string

var LoraDevicesListCmdLimit int64

var LoraDevicesListCmdTagName string

var LoraDevicesListCmdTagValue string

var LoraDevicesListCmdTagValueMatchMode string

var LoraDevicesPutTagsCmd = &cobra.Command{
	Use:   "put-tags",
	Short: TR("lora_devices.put_lora_device_tags.put.summary"),
	Long:  TR(`lora_devices.put_lora_device_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesPutTagsCmdBody string

var LoraDevicesPutTagsCmdDeviceId string

var LoraDevicesRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TR("lora_devices.register_lora_device.post.summary"),
	Long:  TR(`lora_devices.register_lora_device.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesRegisterCmdBody string

var LoraDevicesRegisterCmdDeviceId string

var LoraDevicesSendDataCmd = &cobra.Command{
	Use:   "send-data",
	Short: TR("lora_devices.send_data_to_lora_device.post.summary"),
	Long:  TR(`lora_devices.send_data_to_lora_device.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesSendDataCmdBody string

var LoraDevicesSendDataCmdData string

var LoraDevicesSendDataCmdDeviceId string

var LoraDevicesSetGroupCmd = &cobra.Command{
	Use:   "set-group",
	Short: TR("lora_devices.set_group.post.summary"),
	Long:  TR(`lora_devices.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

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: TR("lora_devices.terminate_lora_device.post.summary"),
	Long:  TR(`lora_devices.terminate_lora_device.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesTerminateCmdDeviceId string

var LoraDevicesUnsetGroupCmd = &cobra.Command{
	Use:   "unset-group",
	Short: TR("lora_devices.unset_group.post.summary"),
	Long:  TR(`lora_devices.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesUnsetGroupCmdDeviceId string

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

var OperatorAuthKeysDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TR("operator.delete_operator_auth_key.delete.summary"),
	Long:  TR(`operator.delete_operator_auth_key.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorAuthKeysDeleteCmdAuthKeyId string

var OperatorAuthKeysDeleteCmdOperatorId string

var OperatorAuthKeysGenerateCmd = &cobra.Command{
	Use:   "generate",
	Short: TR("operator.generate_operator_auth_key.post.summary"),
	Long:  TR(`operator.generate_operator_auth_key.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorAuthKeysGenerateCmdOperatorId string

var OperatorAuthKeysListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("operator.list_operator_auth_keys.get.summary"),
	Long:  TR(`operator.list_operator_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorAuthKeysListCmdOperatorId string

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

var OperatorCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("operator.create_operator.post.summary"),
	Long:  TR(`operator.create_operator.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorCreateCmdBody string

var OperatorCreateCmdEmail string

var OperatorCreateCmdPassword string

var OperatorGenerateApiTokenCmd = &cobra.Command{
	Use:   "generate-api-token",
	Short: TR("operator.generate_auth_token.post.summary"),
	Long:  TR(`operator.generate_auth_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorGenerateApiTokenCmdBody string

var OperatorGenerateApiTokenCmdOperatorId string

var OperatorGenerateApiTokenCmdTokenTimeoutSeconds int64

var OperatorGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("operator.get_operator.get.summary"),
	Long:  TR(`operator.get_operator.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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorGetCmdOperatorId string

var OperatorGetSupportTokenCmd = &cobra.Command{
	Use:   "get-support-token",
	Short: TR("operator.generate_support_token.post.summary"),
	Long:  TR(`operator.generate_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorGetSupportTokenCmdOperatorId string

var OperatorIssueEmailChangeTokenCmd = &cobra.Command{
	Use:   "issue-email-change-token",
	Short: TR("operator.issue_email_change_token.post.summary"),
	Long:  TR(`operator.issue_email_change_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 := collectOperatorIssueEmailChangeTokenCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorIssueEmailChangeTokenCmdBody string

var OperatorIssueEmailChangeTokenCmdEmail string

var OperatorUpdatePasswordCmd = &cobra.Command{
	Use:   "update-password",
	Short: TR("operator.update_operator_password.post.summary"),
	Long:  TR(`operator.update_operator_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()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorUpdatePasswordCmdBody string

var OperatorUpdatePasswordCmdCurrentPassword string

var OperatorUpdatePasswordCmdNewPassword string

var OperatorUpdatePasswordCmdOperatorId string

var OperatorVerifyCmd = &cobra.Command{
	Use:   "verify",
	Short: TR("operator.verify_operator.post.summary"),
	Long:  TR(`operator.verify_operator.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 := collectOperatorVerifyCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorVerifyCmdBody string

var OperatorVerifyCmdToken string

var OperatorVerifyEmailChangeTokenCmd = &cobra.Command{
	Use:   "verify-email-change-token",
	Short: TR("operator.verify_email_change_token.post.summary"),
	Long:  TR(`operator.verify_email_change_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 := collectOperatorVerifyEmailChangeTokenCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorVerifyEmailChangeTokenCmdBody string

var OperatorVerifyEmailChangeTokenCmdToken string

var OrdersCancelCmd = &cobra.Command{
	Use:   "cancel",
	Short: TR("orders.cancel_order.put.summary"),
	Long:  TR(`orders.cancel_order.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 := collectOrdersCancelCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OrdersCancelCmdOrderId string

var OrdersCmd = &cobra.Command{
	Use:   "orders",
	Short: TR("orders.cli.summary"),
	Long:  TR(`orders.cli.description`),
}

var OrdersConfirmCmd = &cobra.Command{
	Use:   "confirm",
	Short: TR("orders.confirm_order.put.summary"),
	Long:  TR(`orders.confirm_order.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 := collectOrdersConfirmCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OrdersConfirmCmdOrderId string

var OrdersCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("orders.create_quotation.post.summary"),
	Long:  TR(`orders.create_quotation.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 := collectOrdersCreateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OrdersCreateCmdBody string

var OrdersCreateCmdShippingAddressId string

var OrdersGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("orders.get_order.get.summary"),
	Long:  TR(`orders.get_order.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 := collectOrdersGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OrdersGetCmdOrderId string

var OrdersListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("orders.list_orders.get.summary"),
	Long:  TR(`orders.list_orders.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 := collectOrdersListCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OrdersListSubscribersCmd = &cobra.Command{
	Use:   "list-subscribers",
	Short: TR("orders.list_ordered_subscriber.get.summary"),
	Long:  TR(`orders.list_ordered_subscriber.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 := collectOrdersListSubscribersCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OrdersListSubscribersCmdLastEvaluatedKey string

var OrdersListSubscribersCmdLimit int64

var OrdersListSubscribersCmdOrderId string

var OrdersRegisterSubscribersCmd = &cobra.Command{
	Use:   "register-subscribers",
	Short: TR("orders.register_ordered_sim.post.summary"),
	Long:  TR(`orders.register_ordered_sim.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 := collectOrdersRegisterSubscribersCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OrdersRegisterSubscribersCmdOrderId string

var PayerInformationCmd = &cobra.Command{
	Use:   "payer-information",
	Short: TR("payment.payer_information.cli.summary"),
	Long:  TR(`payment.payer_information.cli.description`),
}

var PayerInformationGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("payment.payer_information.get.summary"),
	Long:  TR(`payment.payer_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 := collectPayerInformationGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var PayerInformationRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TR("payment.payer_information.post.summary"),
	Long:  TR(`payment.payer_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 := collectPayerInformationRegisterCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var PayerInformationRegisterCmdBody string

var PayerInformationRegisterCmdCompanyName string

var PayerInformationRegisterCmdDepartment string

var PayerInformationRegisterCmdFullName string

var PaymentHistoryCmd = &cobra.Command{
	Use:   "payment-history",
	Short: TR("payment_history.cli.summary"),
	Long:  TR(`payment_history.cli.description`),
}

var PaymentHistoryGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("payment.get_payment_transaction.get.summary"),
	Long:  TR(`payment.get_payment_transaction.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 := collectPaymentHistoryGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var PaymentHistoryGetCmdPaymentTransactionId string

var PaymentMethodsCmd = &cobra.Command{
	Use:   "payment-methods",
	Short: TR("payment_methods.cli.summary"),
	Long:  TR(`payment_methods.cli.description`),
}

var PaymentMethodsGetCurrentCmd = &cobra.Command{
	Use:   "get-current",
	Short: TR("payment.get_payment_method.get.summary"),
	Long:  TR(`payment.get_payment_method.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 := collectPaymentMethodsGetCurrentCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var PaymentMethodsReactivateCurrentCmd = &cobra.Command{
	Use:   "reactivate-current",
	Short: TR("payment.activate_payment_method.post.summary"),
	Long:  TR(`payment.activate_payment_method.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 := collectPaymentMethodsReactivateCurrentCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var PaymentMethodsWebpayCmd = &cobra.Command{
	Use:   "webpay",
	Short: TR("payment_methods.webpay.cli.summary"),
	Long:  TR(`payment_methods.webpay.cli.description`),
}

var PaymentMethodsWebpayRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TR("payment.register_webpay_payment_method.post.summary"),
	Long:  TR(`payment.register_webpay_payment_method.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 := collectPaymentMethodsWebpayRegisterCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var PaymentMethodsWebpayRegisterCmdBody string

var PaymentMethodsWebpayRegisterCmdCvc string

var PaymentMethodsWebpayRegisterCmdExpireMonth int64

var PaymentMethodsWebpayRegisterCmdExpireYear int64

var PaymentMethodsWebpayRegisterCmdName string

var PaymentMethodsWebpayRegisterCmdNumber string

var PaymentStatementsCmd = &cobra.Command{
	Use:   "payment-statements",
	Short: TR("payment_statements.cli.summary"),
	Long:  TR(`payment_statements.cli.description`),
}

var PaymentStatementsExportCmd = &cobra.Command{
	Use:   "export",
	Short: TR("payment.export_payment_statement.post.summary"),
	Long:  TR(`payment.export_payment_statement.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 := collectPaymentStatementsExportCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var PaymentStatementsExportCmdExportMode string

var PaymentStatementsExportCmdPaymentStatementId string

var PaymentStatementsListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("payment.list_payment_statements.get.summary"),
	Long:  TR(`payment.list_payment_statements.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 := collectPaymentStatementsListCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var ProductsCmd = &cobra.Command{
	Use:   "products",
	Short: TR("products.cli.summary"),
	Long:  TR(`products.cli.description`),
}

var ProductsListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("orders.list_products.get.summary"),
	Long:  TR(`orders.list_products.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 := collectProductsListCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var RolesCmd = &cobra.Command{
	Use:   "roles",
	Short: TR("roles.cli.summary"),
	Long:  TR(`roles.cli.description`),
}

var RolesCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("roles.create_role.post.summary"),
	Long:  TR(`roles.create_role.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 := collectRolesCreateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var RolesCreateCmdBody string

var RolesCreateCmdDescription string

var RolesCreateCmdOperatorId string

var RolesCreateCmdPermission string

var RolesCreateCmdRoleId string

var RolesDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TR("roles.delete_role.delete.summary"),
	Long:  TR(`roles.delete_role.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 := collectRolesDeleteCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var RolesDeleteCmdOperatorId string

var RolesDeleteCmdRoleId string

var RolesGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("roles.get_role.get.summary"),
	Long:  TR(`roles.get_role.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 := collectRolesGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var RolesGetCmdOperatorId string

var RolesGetCmdRoleId string

var RolesListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("roles.list_roles.get.summary"),
	Long:  TR(`roles.list_roles.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 := collectRolesListCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var RolesListCmdOperatorId string

var RolesListUsersCmd = &cobra.Command{
	Use:   "list-users",
	Short: TR("roles.list_role_attached_users.get.summary"),
	Long:  TR(`roles.list_role_attached_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 := collectRolesListUsersCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var RolesListUsersCmdOperatorId string

var RolesListUsersCmdRoleId string

var RolesUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TR("roles.update_role.put.summary"),
	Long:  TR(`roles.update_role.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 := collectRolesUpdateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var RolesUpdateCmdBody string

var RolesUpdateCmdDescription string

var RolesUpdateCmdOperatorId string

var RolesUpdateCmdPermission string

var RolesUpdateCmdRoleId string

var RootCmd = &cobra.Command{
	Use:   "soracom",
	Short: "soracom command",
	Long:  `A command line tool to invoke SORACOM API`,
}

var ShippingAddressesCmd = &cobra.Command{
	Use:   "shipping-addresses",
	Short: TR("shipping_addresses.cli.summary"),
	Long:  TR(`shipping_addresses.cli.description`),
}

var ShippingAddressesCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("shipping_addresses.create_shipping_address.post.summary"),
	Long:  TR(`shipping_addresses.create_shipping_address.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 := collectShippingAddressesCreateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var ShippingAddressesCreateCmdAddressLine1 string

var ShippingAddressesCreateCmdAddressLine2 string

var ShippingAddressesCreateCmdBody string

var ShippingAddressesCreateCmdBuilding string

var ShippingAddressesCreateCmdCity string

var ShippingAddressesCreateCmdCompanyName string

var ShippingAddressesCreateCmdDepartment string

var ShippingAddressesCreateCmdFullName string

var ShippingAddressesCreateCmdOperatorId string

var ShippingAddressesCreateCmdPhoneNumber string

var ShippingAddressesCreateCmdState string

var ShippingAddressesCreateCmdZipCode string

var ShippingAddressesDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TR("shipping_addresses.delete_shipping_address.delete.summary"),
	Long:  TR(`shipping_addresses.delete_shipping_address.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 := collectShippingAddressesDeleteCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var ShippingAddressesDeleteCmdOperatorId string

var ShippingAddressesDeleteCmdShippingAddressId string

var ShippingAddressesGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("shipping_addresses.get_shipping_address.get.summary"),
	Long:  TR(`shipping_addresses.get_shipping_address.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 := collectShippingAddressesGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var ShippingAddressesGetCmdOperatorId string

var ShippingAddressesGetCmdShippingAddressId string

var ShippingAddressesListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("shipping_addresses.list_shipping_addresses.get.summary"),
	Long:  TR(`shipping_addresses.list_shipping_addresses.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 := collectShippingAddressesListCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var ShippingAddressesListCmdOperatorId string

var ShippingAddressesUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TR("shipping_addresses.update_shipping_address.put.summary"),
	Long:  TR(`shipping_addresses.update_shipping_address.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 := collectShippingAddressesUpdateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var ShippingAddressesUpdateCmdAddressLine1 string

var ShippingAddressesUpdateCmdAddressLine2 string

var ShippingAddressesUpdateCmdBody string

var ShippingAddressesUpdateCmdBuilding string

var ShippingAddressesUpdateCmdCity string

var ShippingAddressesUpdateCmdCompanyName string

var ShippingAddressesUpdateCmdDepartment string

var ShippingAddressesUpdateCmdFullName string

var ShippingAddressesUpdateCmdOperatorId string

var ShippingAddressesUpdateCmdPhoneNumber string

var ShippingAddressesUpdateCmdShippingAddressId string

var ShippingAddressesUpdateCmdState string

var ShippingAddressesUpdateCmdZipCode string

var StatsAirCmd = &cobra.Command{
	Use:   "air",
	Short: TR("stats.air.cli.summary"),
	Long:  TR(`stats.air.cli.description`),
}

var StatsAirExportCmd = &cobra.Command{
	Use:   "export",
	Short: TR("stats.export_air_stats.post.summary"),
	Long:  TR(`stats.export_air_stats.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 := collectStatsAirExportCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var StatsAirExportCmdBody string

var StatsAirExportCmdExportMode string

var StatsAirExportCmdFrom int64

var StatsAirExportCmdOperatorId string

var StatsAirExportCmdPeriod string

var StatsAirExportCmdTo int64

var StatsAirGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("stats.get_air_stats.get.summary"),
	Long:  TR(`stats.get_air_stats.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 := collectStatsAirGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var StatsAirGetCmdFrom int64

var StatsAirGetCmdImsi string

var StatsAirGetCmdPeriod string

var StatsAirGetCmdTo int64

var StatsBeamCmd = &cobra.Command{
	Use:   "beam",
	Short: TR("stats.beam.cli.summary"),
	Long:  TR(`stats.beam.cli.description`),
}

var StatsBeamExportCmd = &cobra.Command{
	Use:   "export",
	Short: TR("stats.export_beam_stats.post.summary"),
	Long:  TR(`stats.export_beam_stats.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 := collectStatsBeamExportCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var StatsBeamExportCmdBody string

var StatsBeamExportCmdExportMode string

var StatsBeamExportCmdFrom int64

var StatsBeamExportCmdOperatorId string

var StatsBeamExportCmdPeriod string

var StatsBeamExportCmdTo int64

var StatsBeamGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("stats.get_beam_stats.get.summary"),
	Long:  TR(`stats.get_beam_stats.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 := collectStatsBeamGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var StatsBeamGetCmdFrom int64

var StatsBeamGetCmdImsi string

var StatsBeamGetCmdPeriod string

var StatsBeamGetCmdTo int64

var StatsCmd = &cobra.Command{
	Use:   "stats",
	Short: TR("stats.cli.summary"),
	Long:  TR(`stats.cli.description`),
}

var SubscribersActivateCmd = &cobra.Command{
	Use:   "activate",
	Short: TR("subscribers.activate_subscriber.post.summary"),
	Long:  TR(`subscribers.activate_subscriber.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 := collectSubscribersActivateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersActivateCmdImsi string

var SubscribersCmd = &cobra.Command{
	Use:   "subscribers",
	Short: TR("subscribers.cli.summary"),
	Long:  TR(`subscribers.cli.description`),
}

var SubscribersDeactivateCmd = &cobra.Command{
	Use:   "deactivate",
	Short: TR("subscribers.deactivate_subscriber.post.summary"),
	Long:  TR(`subscribers.deactivate_subscriber.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 := collectSubscribersDeactivateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersDeactivateCmdImsi string

var SubscribersDeleteSessionCmd = &cobra.Command{
	Use:   "delete-session",
	Short: TR("subscribers.delete_session.post.summary"),
	Long:  TR(`subscribers.delete_session.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 := collectSubscribersDeleteSessionCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersDeleteSessionCmdImsi string

var SubscribersDeleteTagCmd = &cobra.Command{
	Use:   "delete-tag",
	Short: TR("subscribers.delete_subscriber_tag.delete.summary"),
	Long:  TR(`subscribers.delete_subscriber_tag.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 := collectSubscribersDeleteTagCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersDeleteTagCmdImsi string

var SubscribersDeleteTagCmdTagName string

var SubscribersDeleteTransferTokenCmd = &cobra.Command{
	Use:   "delete-transfer-token",
	Short: TR("subscribers.delete_subscriber_transfer_token.delete.summary"),
	Long:  TR(`subscribers.delete_subscriber_transfer_token.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 := collectSubscribersDeleteTransferTokenCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersDeleteTransferTokenCmdToken string

var SubscribersDisableTerminationCmd = &cobra.Command{
	Use:   "disable-termination",
	Short: TR("subscribers.disable_termination.post.summary"),
	Long:  TR(`subscribers.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 := collectSubscribersDisableTerminationCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersDisableTerminationCmdImsi string

var SubscribersEnableTerminationCmd = &cobra.Command{
	Use:   "enable-termination",
	Short: TR("subscribers.enable_termination.post.summary"),
	Long:  TR(`subscribers.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 := collectSubscribersEnableTerminationCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersEnableTerminationCmdImsi string

var SubscribersGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("subscribers.get_subscriber.get.summary"),
	Long:  TR(`subscribers.get_subscriber.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 := collectSubscribersGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersGetCmdImsi string

var SubscribersGetDataCmd = &cobra.Command{
	Use:   "get-data",
	Short: TR("subscribers.get_data_from_subscriber.get.summary"),
	Long:  TR(`subscribers.get_data_from_subscriber.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 := collectSubscribersGetDataCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersGetDataCmdFrom int64

var SubscribersGetDataCmdImsi string

var SubscribersGetDataCmdLastEvaluatedKey string

var SubscribersGetDataCmdLimit int64

var SubscribersGetDataCmdSort string

var SubscribersGetDataCmdTo int64

var SubscribersIssueTransferTokenCmd = &cobra.Command{
	Use:   "issue-transfer-token",
	Short: TR("subscribers.issue_subscriber_transfer_token.post.summary"),
	Long:  TR(`subscribers.issue_subscriber_transfer_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 := collectSubscribersIssueTransferTokenCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersIssueTransferTokenCmdBody string

var SubscribersIssueTransferTokenCmdTransferDestinationOperatorEmail string

var SubscribersIssueTransferTokenCmdTransferDestinationOperatorId string

var SubscribersListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("subscribers.list_subscribers.get.summary"),
	Long:  TR(`subscribers.list_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 := collectSubscribersListCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersListCmdLastEvaluatedKey string

var SubscribersListCmdLimit int64

var SubscribersListCmdSerialNumberFilter string

var SubscribersListCmdSpeedClassFilter string

var SubscribersListCmdStatusFilter string

var SubscribersListCmdTagName string

var SubscribersListCmdTagValue string

var SubscribersListCmdTagValueMatchMode string

var SubscribersPutTagsCmd = &cobra.Command{
	Use:   "put-tags",
	Short: TR("subscribers.put_subscriber_tags.put.summary"),
	Long:  TR(`subscribers.put_subscriber_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 := collectSubscribersPutTagsCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersPutTagsCmdBody string

var SubscribersPutTagsCmdImsi string

var SubscribersRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TR("subscribers.register_subscriber.post.summary"),
	Long:  TR(`subscribers.register_subscriber.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 := collectSubscribersRegisterCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersRegisterCmdBody string

var SubscribersRegisterCmdGroupId string

var SubscribersRegisterCmdImsi string

var SubscribersRegisterCmdRegistrationSecret string

var SubscribersSessionEventsCmd = &cobra.Command{
	Use:   "session-events",
	Short: TR("subscribers.list_session_events.get.summary"),
	Long:  TR(`subscribers.list_session_events.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 := collectSubscribersSessionEventsCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersSessionEventsCmdFrom int64

var SubscribersSessionEventsCmdImsi string

var SubscribersSessionEventsCmdLastEvaluatedKey string

var SubscribersSessionEventsCmdLimit int64

var SubscribersSessionEventsCmdTo int64

var SubscribersSetExpiryTimeCmd = &cobra.Command{
	Use:   "set-expiry-time",
	Short: TR("subscribers.set_expirytime.post.summary"),
	Long:  TR(`subscribers.set_expirytime.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 := collectSubscribersSetExpiryTimeCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersSetExpiryTimeCmdBody string

var SubscribersSetExpiryTimeCmdExpiryAction string

var SubscribersSetExpiryTimeCmdExpiryTime int64

var SubscribersSetExpiryTimeCmdImsi string

var SubscribersSetGroupCmd = &cobra.Command{
	Use:   "set-group",
	Short: TR("subscribers.set_group.post.summary"),
	Long:  TR(`subscribers.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 := collectSubscribersSetGroupCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersSetGroupCmdBody string

var SubscribersSetGroupCmdGroupId string

var SubscribersSetGroupCmdImsi string

var SubscribersSetImeiLockCmd = &cobra.Command{
	Use:   "set-imei-lock",
	Short: TR("subscribers.set_imei_lock.post.summary"),
	Long:  TR(`subscribers.set_imei_lock.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 := collectSubscribersSetImeiLockCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersSetImeiLockCmdBody string

var SubscribersSetImeiLockCmdImei string

var SubscribersSetImeiLockCmdImsi string

var SubscribersSuspendCmd = &cobra.Command{
	Use:   "suspend",
	Short: TR("subscribers.suspend_subscriber.post.summary"),
	Long:  TR(`subscribers.suspend_subscriber.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 := collectSubscribersSuspendCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersSuspendCmdImsi string

var SubscribersTerminateCmd = &cobra.Command{
	Use:   "terminate",
	Short: TR("subscribers.terminate_subscriber.post.summary"),
	Long:  TR(`subscribers.terminate_subscriber.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 := collectSubscribersTerminateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersTerminateCmdImsi string

var SubscribersUnsetExpiryTimeCmd = &cobra.Command{
	Use:   "unset-expiry-time",
	Short: TR("subscribers.unset_expirytime.post.summary"),
	Long:  TR(`subscribers.unset_expirytime.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 := collectSubscribersUnsetExpiryTimeCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersUnsetExpiryTimeCmdImsi string

var SubscribersUnsetGroupCmd = &cobra.Command{
	Use:   "unset-group",
	Short: TR("subscribers.unset_group.post.summary"),
	Long:  TR(`subscribers.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 := collectSubscribersUnsetGroupCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersUnsetGroupCmdImsi string

var SubscribersUnsetImeiLockCmd = &cobra.Command{
	Use:   "unset-imei-lock",
	Short: TR("subscribers.unset_imei_lock.post.summary"),
	Long:  TR(`subscribers.unset_imei_lock.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 := collectSubscribersUnsetImeiLockCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersUnsetImeiLockCmdImsi string

var SubscribersUpdateSpeedClassCmd = &cobra.Command{
	Use:   "update-speed-class",
	Short: TR("subscribers.update_speedclass.post.summary"),
	Long:  TR(`subscribers.update_speedclass.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 := collectSubscribersUpdateSpeedClassCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersUpdateSpeedClassCmdBody string

var SubscribersUpdateSpeedClassCmdImsi string

var SubscribersUpdateSpeedClassCmdSpeedClass string

var SubscribersVerifyTransferTokenCmd = &cobra.Command{
	Use:   "verify-transfer-token",
	Short: TR("subscribers.verify_subscriber_transfer_token.post.summary"),
	Long:  TR(`subscribers.verify_subscriber_transfer_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 := collectSubscribersVerifyTransferTokenCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var SubscribersVerifyTransferTokenCmdBody string

var SubscribersVerifyTransferTokenCmdToken string

var UsersAttachRoleCmd = &cobra.Command{
	Use:   "attach-role",
	Short: TR("roles.attach_role.post.summary"),
	Long:  TR(`roles.attach_role.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 := collectUsersAttachRoleCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersAttachRoleCmdBody string

var UsersAttachRoleCmdOperatorId string

var UsersAttachRoleCmdRoleId string

var UsersAttachRoleCmdUserName string

var UsersAuthKeysCmd = &cobra.Command{
	Use:   "auth-keys",
	Short: TR("users.auth_keys.cli.summary"),
	Long:  TR(`users.auth_keys.cli.description`),
}

var UsersAuthKeysDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TR("users.delete_user_auth_key.delete.summary"),
	Long:  TR(`users.delete_user_auth_key.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 := collectUsersAuthKeysDeleteCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersAuthKeysDeleteCmdAuthKeyId string

var UsersAuthKeysDeleteCmdOperatorId string

var UsersAuthKeysDeleteCmdUserName string

var UsersAuthKeysGenerateCmd = &cobra.Command{
	Use:   "generate",
	Short: TR("users.generate_user_auth_key.post.summary"),
	Long:  TR(`users.generate_user_auth_key.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 := collectUsersAuthKeysGenerateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersAuthKeysGenerateCmdOperatorId string

var UsersAuthKeysGenerateCmdUserName string

var UsersAuthKeysGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("users.get_user_auth_key.get.summary"),
	Long:  TR(`users.get_user_auth_key.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 := collectUsersAuthKeysGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersAuthKeysGetCmdAuthKeyId string

var UsersAuthKeysGetCmdOperatorId string

var UsersAuthKeysGetCmdUserName string

var UsersAuthKeysListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("users.list_user_auth_keys.get.summary"),
	Long:  TR(`users.list_user_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 := collectUsersAuthKeysListCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersAuthKeysListCmdOperatorId string

var UsersAuthKeysListCmdUserName string

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

var UsersCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("users.create_user.post.summary"),
	Long:  TR(`users.create_user.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 := collectUsersCreateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersCreateCmdBody string

var UsersCreateCmdDescription string

var UsersCreateCmdOperatorId string

var UsersCreateCmdUserName string

var UsersDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TR("users.delete_user.delete.summary"),
	Long:  TR(`users.delete_user.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 := collectUsersDeleteCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersDeleteCmdOperatorId string

var UsersDeleteCmdUserName string

var UsersDetachRoleCmd = &cobra.Command{
	Use:   "detach-role",
	Short: TR("roles.detach_role.delete.summary"),
	Long:  TR(`roles.detach_role.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 := collectUsersDetachRoleCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersDetachRoleCmdOperatorId string

var UsersDetachRoleCmdRoleId string

var UsersDetachRoleCmdUserName string

var UsersGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("users.get_user.get.summary"),
	Long:  TR(`users.get_user.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 := collectUsersGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersGetCmdOperatorId string

var UsersGetCmdUserName string

var UsersListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("users.list_users.get.summary"),
	Long:  TR(`users.list_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 := collectUsersListCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersListCmdOperatorId string

var UsersListRolesCmd = &cobra.Command{
	Use:   "list-roles",
	Short: TR("roles.list_user_roles.get.summary"),
	Long:  TR(`roles.list_user_roles.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 := collectUsersListRolesCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersListRolesCmdOperatorId string

var UsersListRolesCmdUserName string

var UsersPasswordCmd = &cobra.Command{
	Use:   "password",
	Short: TR("users.password.cli.summary"),
	Long:  TR(`users.password.cli.description`),
}

var UsersPasswordConfiguredCmd = &cobra.Command{
	Use:   "configured",
	Short: TR("users.has_user_password.get.summary"),
	Long:  TR(`users.has_user_password.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 := collectUsersPasswordConfiguredCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersPasswordConfiguredCmdOperatorId string

var UsersPasswordConfiguredCmdUserName string

var UsersPasswordCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("users.create_user_password.post.summary"),
	Long:  TR(`users.create_user_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 := collectUsersPasswordCreateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersPasswordCreateCmdBody string

var UsersPasswordCreateCmdOperatorId string

var UsersPasswordCreateCmdPassword string

var UsersPasswordCreateCmdUserName string

var UsersPasswordDeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: TR("users.delete_user_password.delete.summary"),
	Long:  TR(`users.delete_user_password.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 := collectUsersPasswordDeleteCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersPasswordDeleteCmdOperatorId string

var UsersPasswordDeleteCmdUserName string

var UsersPasswordUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TR("users.update_user_password.put.summary"),
	Long:  TR(`users.update_user_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 := collectUsersPasswordUpdateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersPasswordUpdateCmdBody string

var UsersPasswordUpdateCmdCurrentPassword string

var UsersPasswordUpdateCmdNewPassword string

var UsersPasswordUpdateCmdOperatorId string

var UsersPasswordUpdateCmdUserName string

var UsersPermissionsCmd = &cobra.Command{
	Use:   "permissions",
	Short: TR("users.permissions.cli.summary"),
	Long:  TR(`users.permissions.cli.description`),
}

var UsersPermissionsGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("users.get_user_permission.get.summary"),
	Long:  TR(`users.get_user_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 := collectUsersPermissionsGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersPermissionsGetCmdOperatorId string

var UsersPermissionsGetCmdUserName string

var UsersPermissionsUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TR("users.update_user_permission.put.summary"),
	Long:  TR(`users.update_user_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 := collectUsersPermissionsUpdateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersPermissionsUpdateCmdBody string

var UsersPermissionsUpdateCmdDescription string

var UsersPermissionsUpdateCmdOperatorId string

var UsersPermissionsUpdateCmdPermission string

var UsersPermissionsUpdateCmdUserName string

var UsersUpdateCmd = &cobra.Command{
	Use:   "update",
	Short: TR("users.update_user.put.summary"),
	Long:  TR(`users.update_user.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 := collectUsersUpdateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var UsersUpdateCmdBody string

var UsersUpdateCmdDescription string

var UsersUpdateCmdOperatorId string

var UsersUpdateCmdUserName string

var VersionCmd = &cobra.Command{
	Use:   "version",
	Short: TR("version.cli.summary"),
	Long:  TR("version.cli.description"),
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Printf("SORACOM API client v%s\n", version)
	},
}

var VpgCloseGateCmd = &cobra.Command{
	Use:   "close-gate",
	Short: TR("virtual_private_gateway.close_gate.post.summary"),
	Long:  TR(`virtual_private_gateway.close_gate.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 := collectVpgCloseGateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgCloseGateCmdVpgId string

var VpgCmd = &cobra.Command{
	Use:   "vpg",
	Short: TR("virtual_private_gateway.cli.summary"),
	Long:  TR(`virtual_private_gateway.cli.description`),
}

var VpgCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TR("virtual_private_gateway.create_virtual_private_gateway.post.summary"),
	Long:  TR(`virtual_private_gateway.create_virtual_private_gateway.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 := collectVpgCreateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgCreateCmdBody string

var VpgCreateCmdDeviceSubnetCidrRange string

var VpgCreateCmdPrimaryServiceName string

var VpgCreateCmdUseInternetGateway bool

var VpgCreateVpcPeeringConnectionCmd = &cobra.Command{
	Use:   "create-vpc-peering-connection",
	Short: TR("virtual_private_gateway.create_vpc_peering_connection.post.summary"),
	Long:  TR(`virtual_private_gateway.create_vpc_peering_connection.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 := collectVpgCreateVpcPeeringConnectionCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgCreateVpcPeeringConnectionCmdBody string

var VpgCreateVpcPeeringConnectionCmdDestinationCidrBlock string

var VpgCreateVpcPeeringConnectionCmdPeerOwnerId string

var VpgCreateVpcPeeringConnectionCmdPeerVpcId string

var VpgCreateVpcPeeringConnectionCmdVpgId string

var VpgDeleteIpAddressMapEntryCmd = &cobra.Command{
	Use:   "delete-ip-address-map-entry",
	Short: TR("virtual_private_gateway.delete_virtual_private_gateway_ip_address_map_entry.delete.summary"),
	Long:  TR(`virtual_private_gateway.delete_virtual_private_gateway_ip_address_map_entry.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 := collectVpgDeleteIpAddressMapEntryCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgDeleteIpAddressMapEntryCmdKey string

var VpgDeleteIpAddressMapEntryCmdVpgId string

var VpgDeleteVpcPeeringConnectionCmd = &cobra.Command{
	Use:   "delete-vpc-peering-connection",
	Short: TR("virtual_private_gateway.delete_vpc_peering_connection.delete.summary"),
	Long:  TR(`virtual_private_gateway.delete_vpc_peering_connection.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 := collectVpgDeleteVpcPeeringConnectionCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgDeleteVpcPeeringConnectionCmdPcxId string

var VpgDeleteVpcPeeringConnectionCmdVpgId string

var VpgGetCmd = &cobra.Command{
	Use:   "get",
	Short: TR("virtual_private_gateway.get_virtual_private_gateway.get.summary"),
	Long:  TR(`virtual_private_gateway.get_virtual_private_gateway.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 := collectVpgGetCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgGetCmdVpgId string

var VpgListCmd = &cobra.Command{
	Use:   "list",
	Short: TR("virtual_private_gateway.list_virtual_private_gateways.get.summary"),
	Long:  TR(`virtual_private_gateway.list_virtual_private_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 := collectVpgListCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgListCmdLastEvaluatedKey string

var VpgListCmdLimit int64

var VpgListCmdTagName string

var VpgListCmdTagValue string

var VpgListCmdTagValueMatchMode string

var VpgListGatePeersCmd = &cobra.Command{
	Use:   "list-gate-peers",
	Short: TR("virtual_private_gateway.list_virtual_private_gateway_peers.get.summary"),
	Long:  TR(`virtual_private_gateway.list_virtual_private_gateway_peers.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 := collectVpgListGatePeersCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgListGatePeersCmdVpgId string

var VpgListIpAddressMapEntriesCmd = &cobra.Command{
	Use:   "list-ip-address-map-entries",
	Short: TR("virtual_private_gateway.list_virtual_private_gateway_ip_address_map_entries.get.summary"),
	Long:  TR(`virtual_private_gateway.list_virtual_private_gateway_ip_address_map_entries.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 := collectVpgListIpAddressMapEntriesCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgListIpAddressMapEntriesCmdVpgId string

var VpgOpenGateCmd = &cobra.Command{
	Use:   "open-gate",
	Short: TR("virtual_private_gateway.open_gate.post.summary"),
	Long:  TR(`virtual_private_gateway.open_gate.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 := collectVpgOpenGateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgOpenGateCmdVpgId string

var VpgPutIpAddressMapEntryCmd = &cobra.Command{
	Use:   "put-ip-address-map-entry",
	Short: TR("virtual_private_gateway.put_virtual_private_gateway_ip_address_map_entry.post.summary"),
	Long:  TR(`virtual_private_gateway.put_virtual_private_gateway_ip_address_map_entry.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 := collectVpgPutIpAddressMapEntryCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgPutIpAddressMapEntryCmdBody string

var VpgPutIpAddressMapEntryCmdIpAddress string

var VpgPutIpAddressMapEntryCmdKey string

var VpgPutIpAddressMapEntryCmdVpgId string

var VpgRegisterGatePeerCmd = &cobra.Command{
	Use:   "register-gate-peer",
	Short: TR("virtual_private_gateway.register_virtual_private_gateway_peer.post.summary"),
	Long:  TR(`virtual_private_gateway.register_virtual_private_gateway_peer.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 := collectVpgRegisterGatePeerCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgRegisterGatePeerCmdBody string

var VpgRegisterGatePeerCmdInnerIpAddress string

var VpgRegisterGatePeerCmdOuterIpAddress string

var VpgRegisterGatePeerCmdVpgId string

var VpgTerminateCmd = &cobra.Command{
	Use:   "terminate",
	Short: TR("virtual_private_gateway.terminate_virtual_private_gateway.post.summary"),
	Long:  TR(`virtual_private_gateway.terminate_virtual_private_gateway.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 := collectVpgTerminateCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgTerminateCmdVpgId string

var VpgUnregisterGatePeerCmd = &cobra.Command{
	Use:   "unregister-gate-peer",
	Short: TR("virtual_private_gateway.unregister_virtual_private_gateway_peer.delete.summary"),
	Long:  TR(`virtual_private_gateway.unregister_virtual_private_gateway_peer.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 := collectVpgUnregisterGatePeerCmdParams()
		if err != nil {
			return err
		}

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var VpgUnregisterGatePeerCmdOuterIpAddress string

var VpgUnregisterGatePeerCmdVpgId string