cmd

var Assets = assets.NewFileSystem(map[string][]string{"/": {"soracom-api.en.yaml", "soracom-api.ja.yaml", "soracom-api.zh.yaml"}, "/cli": {"en.yaml", "ja.yaml", "zh.yaml"}}, map[string]*assets.File{
	"/cli": {
		Path:     "/cli",
		FileMode: 0x800001ed,
		Mtime:    time.Unix(1514186848, 1514186848000000000),
		Data:     nil,
	}, "/cli/en.yaml": {
		Path:     "/cli/en.yaml",
		FileMode: 0x1a4,
		Mtime:    time.Unix(1530594548, 1530594548000000000),
		Data:     []byte(_Assets5c7a5c077bf08178252e3232f159748d3047d4e1),
	}, "/cli/ja.yaml": {
		Path:     "/cli/ja.yaml",
		FileMode: 0x1a4,
		Mtime:    time.Unix(1530594569, 1530594569000000000),
		Data:     []byte(_Assetsc656f9a20bab5c445f670257a18d5d8b67a927b2),
	}, "/soracom-api.zh.yaml": {
		Path:     "/soracom-api.zh.yaml",
		FileMode: 0x1a4,
		Mtime:    time.Unix(1515554744, 1515554744000000000),
		Data:     []byte(_Assets837c6c90a714d3b9bd86defcecbd1decf63fda58),
	}, "/": {
		Path:     "/",
		FileMode: 0x800001ed,
		Mtime:    time.Unix(1515393982, 1515393982000000000),
		Data:     nil,
	}, "/cli/zh.yaml": {
		Path:     "/cli/zh.yaml",
		FileMode: 0x1a4,
		Mtime:    time.Unix(1514186848, 1514186848000000000),
		Data:     []byte(_Assetse87ac197fdc79da24bbb7c824d9b976647fee4db),
	}, "/soracom-api.en.yaml": {
		Path:     "/soracom-api.en.yaml",
		FileMode: 0x1a4,
		Mtime:    time.Unix(1531212029, 1531212029000000000),
		Data:     []byte(_Assets0764b782d9c1bd06ad125db0a570e6abd04c472c),
	}, "/soracom-api.ja.yaml": {
		Path:     "/soracom-api.ja.yaml",
		FileMode: 0x1a4,
		Mtime:    time.Unix(1531212029, 1531212029000000000),
		Data:     []byte(_Assets6869369ac6cbeb59ff80562bf70e125cfe403b8c),
	}}, "")

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

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

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

		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 AuthCmdMfaOTPCode string

var AuthCmdOperatorId string

var AuthCmdPassword string

var AuthCmdTokenTimeoutSeconds int64

var AuthCmdUserName string

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

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

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

		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: TRAPI("/auth/password_reset_token/verify:post:summary"),
	Long:  TRAPI(`/auth/password_reset_token/verify:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

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

		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: TRCLI("cli.bills.summary"),
	Long:  TRCLI(`cli.bills.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/bills/latest/export:post:summary"),
	Long:  TRAPI(`/bills/latest/export:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/bills/{yyyyMM}:get:summary"),
	Long:  TRAPI(`/bills/{yyyyMM}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/bills/{yyyyMM}/daily:get:summary"),
	Long:  TRAPI(`/bills/{yyyyMM}/daily:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/bills/latest:get:summary"),
	Long:  TRAPI(`/bills/latest:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/bills:get:summary"),
	Long:  TRAPI(`/bills:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRCLI("cli.completion.summary"),
	Long:  TRCLI("cli.completion.description"),
	RunE: func(cmd *cobra.Command, args []string) error {
		err := RootCmd.GenBashCompletion(os.Stdout)
		if err != nil {
			return err
		}
		return nil
	},
}

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

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

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

		return nil
	},
}

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

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

		return prettyPrintObjectAsJSON(p)
	},
}

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/coupons/{coupon_code}/register:post:summary"),
	Long:  TRAPI(`/coupons/{coupon_code}/register:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRCLI("cli.credentials.summary"),
	Long:  TRCLI(`cli.credentials.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/credentials/{credentials_id}:delete:summary"),
	Long:  TRAPI(`/credentials/{credentials_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/credentials:get:summary"),
	Long:  TRAPI(`/credentials:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/credentials/{credentials_id}:put:summary"),
	Long:  TRAPI(`/credentials/{credentials_id}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRCLI("cli.data.summary"),
	Long:  TRCLI(`cli.data.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DataDeleteEntryCmdResourceId string

var DataDeleteEntryCmdResourceType string

var DataDeleteEntryCmdTime int64

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DataGetEntriesCmdFrom int64

var DataGetEntriesCmdLastEvaluatedKey string

var DataGetEntriesCmdLimit int64

var DataGetEntriesCmdResourceId string

var DataGetEntriesCmdResourceType string

var DataGetEntriesCmdSort string

var DataGetEntriesCmdTo int64

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DataGetEntryCmdResourceId string

var DataGetEntryCmdResourceType string

var DataGetEntryCmdTime int64

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DataListSourceResourcesCmdLastEvaluatedKey string

var DataListSourceResourcesCmdLimit int64

var DataListSourceResourcesCmdResourceType string

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesCreateCmdBody string

var DevicesCreateCmdDeviceId string

var DevicesCreateCmdEndpoint string

var DevicesCreateCmdFirmwareVersion string

var DevicesCreateCmdGroupId string

var DevicesCreateCmdIpAddress string

var DevicesCreateCmdLastModifiedTime string

var DevicesCreateCmdLastRegistrationUpdate string

var DevicesCreateCmdManufacturer string

var DevicesCreateCmdModelNumber string

var DevicesCreateCmdOnline bool

var DevicesCreateCmdOperatorId string

var DevicesCreateCmdRegistrationId string

var DevicesCreateCmdRegistrationLifeTime int64

var DevicesCreateCmdSerialNumber string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesCreateObjectModelCmdBody string

var DevicesCreateObjectModelCmdCreatedTime string

var DevicesCreateObjectModelCmdFormat string

var DevicesCreateObjectModelCmdLastModifiedTime string

var DevicesCreateObjectModelCmdObjectId string

var DevicesCreateObjectModelCmdObjectName string

var DevicesCreateObjectModelCmdOperatorId string

var DevicesCreateObjectModelCmdScope string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesDeleteCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesDeleteDeviceTagCmdDeviceId string

var DevicesDeleteDeviceTagCmdTagName string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesDeleteObjectModelCmdModelId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesExecuteResourceCmdBody string

var DevicesExecuteResourceCmdDeviceId string

var DevicesExecuteResourceCmdInstance string

var DevicesExecuteResourceCmdObject string

var DevicesExecuteResourceCmdResource string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesGetCmdDeviceId string

var DevicesGetCmdModel bool

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesGetInstanceCmdDeviceId string

var DevicesGetInstanceCmdInstance string

var DevicesGetInstanceCmdModel bool

var DevicesGetInstanceCmdObject string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesGetObjectModelCmdModelId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesGetResourceCmdDeviceId string

var DevicesGetResourceCmdInstance string

var DevicesGetResourceCmdModel bool

var DevicesGetResourceCmdObject string

var DevicesGetResourceCmdResource string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesListCmdLastEvaluatedKey string

var DevicesListCmdLimit int64

var DevicesListCmdTagName string

var DevicesListCmdTagValue string

var DevicesListCmdTagValueMatchMode string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesListObjectModelsCmdLastEvaluatedKey string

var DevicesListObjectModelsCmdLimit int64

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesObserveResourceCmdDeviceId string

var DevicesObserveResourceCmdInstance string

var DevicesObserveResourceCmdModel bool

var DevicesObserveResourceCmdObject string

var DevicesObserveResourceCmdResource string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesObserveResourcesCmdDeviceId string

var DevicesObserveResourcesCmdInstance string

var DevicesObserveResourcesCmdModel bool

var DevicesObserveResourcesCmdObject string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesPutDeviceTagsCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesPutResourceCmdBody string

var DevicesPutResourceCmdDeviceId string

var DevicesPutResourceCmdInstance string

var DevicesPutResourceCmdObject string

var DevicesPutResourceCmdResource string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesSetGroupCmdBody string

var DevicesSetGroupCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesSetObjectModelScopeCmdBody string

var DevicesSetObjectModelScopeCmdModelId string

var DevicesSetObjectModelScopeCmdScope string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesUnobserveResourceCmdDeviceId string

var DevicesUnobserveResourceCmdInstance string

var DevicesUnobserveResourceCmdObject string

var DevicesUnobserveResourceCmdResource string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesUnobserveResourcesCmdDeviceId string

var DevicesUnobserveResourcesCmdInstance string

var DevicesUnobserveResourcesCmdObject string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesUnsetGroupCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var DevicesUpdateObjectModelCmdBody string

var DevicesUpdateObjectModelCmdCreatedTime string

var DevicesUpdateObjectModelCmdFormat string

var DevicesUpdateObjectModelCmdLastModifiedTime string

var DevicesUpdateObjectModelCmdModelId string

var DevicesUpdateObjectModelCmdObjectId string

var DevicesUpdateObjectModelCmdObjectName string

var DevicesUpdateObjectModelCmdOperatorId string

var DevicesUpdateObjectModelCmdScope string

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/event_handlers/{handler_id}:delete:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/event_handlers/{handler_id}:get:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/event_handlers/{handler_id}/subscribers/{imsi}/ignore:post:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}/subscribers/{imsi}/ignore:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/event_handlers:get:summary"),
	Long:  TRAPI(`/event_handlers:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/event_handlers/subscribers/{imsi}:get:summary"),
	Long:  TRAPI(`/event_handlers/subscribers/{imsi}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/event_handlers/{handler_id}/subscribers/{imsi}/ignore:delete:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}/subscribers/{imsi}/ignore:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/event_handlers/{handler_id}:put:summary"),
	Long:  TRAPI(`/event_handlers/{handler_id}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRCLI("cli.files.summary"),
	Long:  TRCLI(`cli.files.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRCLI("cli.groups.summary"),
	Long:  TRCLI(`cli.groups.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/groups/{group_id}:delete:summary"),
	Long:  TRAPI(`/groups/{group_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/groups/{group_id}/configuration/{namespace}/{name}:delete:summary"),
	Long:  TRAPI(`/groups/{group_id}/configuration/{namespace}/{name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/groups/{group_id}/tags/{tag_name}:delete:summary"),
	Long:  TRAPI(`/groups/{group_id}/tags/{tag_name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/groups/{group_id}:get:summary"),
	Long:  TRAPI(`/groups/{group_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/groups:get:summary"),
	Long:  TRAPI(`/groups:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/groups/{group_id}/subscribers:get:summary"),
	Long:  TRAPI(`/groups/{group_id}/subscribers:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/groups/{group_id}/configuration/{namespace}:put:summary"),
	Long:  TRAPI(`/groups/{group_id}/configuration/{namespace}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/groups/{group_id}/tags:put:summary"),
	Long:  TRAPI(`/groups/{group_id}/tags:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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 LagoonCmd = &cobra.Command{
	Use:   "lagoon",
	Short: TRCLI("cli.lagoon.summary"),
	Long:  TRCLI(`cli.lagoon.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LagoonCreateUserCmdBody string

var LagoonCreateUserCmdRole string

var LagoonCreateUserCmdUserEmail string

var LagoonCreateUserCmdUserPassword string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LagoonDeleteUserCmdLagoonUserId int64

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LagoonRegisterCmdBody string

var LagoonRegisterCmdPlan string

var LagoonRegisterCmdUserPassword string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LagoonUpdateUserEmailCmdBody string

var LagoonUpdateUserEmailCmdLagoonUserId int64

var LagoonUpdateUserEmailCmdUserEmail string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LagoonUpdateUserPasswordCmdBody string

var LagoonUpdateUserPasswordCmdLagoonUserId int64

var LagoonUpdateUserPasswordCmdNewPassword string

var LagoonUpdateUserPasswordCmdOldPassword string

var LagoonUpdateUserPasswordCmdUserEmail string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LagoonUpdateUserPermissionCmdBody string

var LagoonUpdateUserPermissionCmdLagoonUserId int64

var LagoonUpdateUserPermissionCmdRole string

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRCLI("cli.lora-devices.summary"),
	Long:  TRCLI(`cli.lora-devices.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/lora_devices/{device_id}/disable_termination:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/disable_termination:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/lora_devices/{device_id}/enable_termination:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/enable_termination:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/lora_devices/{device_id}:get:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/lora_devices/{device_id}/data:get:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/data:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/lora_devices:get:summary"),
	Long:  TRAPI(`/lora_devices:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/lora_devices/{device_id}/tags:put:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/tags:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/lora_devices/{device_id}/register:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/register:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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 LoraDevicesRegisterCmdGroupId string

var LoraDevicesRegisterCmdRegistrationSecret string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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 LoraDevicesSendDataCmdFPort int64

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/lora_devices/{device_id}/terminate:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/terminate:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/lora_devices/{device_id}/unset_group:post:summary"),
	Long:  TRAPI(`/lora_devices/{device_id}/unset_group:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraDevicesUnsetGroupCmdDeviceId string

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraGatewaysDeleteTagCmdGatewayId string

var LoraGatewaysDeleteTagCmdTagName string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraGatewaysDisableTerminationCmdGatewayId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraGatewaysEnableTerminationCmdGatewayId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraGatewaysGetCmdGatewayId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraGatewaysListCmdLastEvaluatedKey string

var LoraGatewaysListCmdLimit int64

var LoraGatewaysListCmdTagName string

var LoraGatewaysListCmdTagValue string

var LoraGatewaysListCmdTagValueMatchMode string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraGatewaysPutTagsCmdBody string

var LoraGatewaysPutTagsCmdGatewayId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraGatewaysSetNetworkSetCmdBody string

var LoraGatewaysSetNetworkSetCmdGatewayId string

var LoraGatewaysSetNetworkSetCmdNetworkSetId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraGatewaysTerminateCmdGatewayId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraGatewaysUnsetNetworkSetCmdGatewayId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraNetworkSetsAddPermissionCmdBody string

var LoraNetworkSetsAddPermissionCmdNsId string

var LoraNetworkSetsAddPermissionCmdOperatorId string

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraNetworkSetsCreateCmdBody string

var LoraNetworkSetsCreateCmdCreatedTime string

var LoraNetworkSetsCreateCmdLastModifiedTime string

var LoraNetworkSetsCreateCmdNetworkSetId string

var LoraNetworkSetsCreateCmdOperatorId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraNetworkSetsDeleteCmdNsId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraNetworkSetsDeleteTagCmdNsId string

var LoraNetworkSetsDeleteTagCmdTagName string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraNetworkSetsGetCmdNsId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraNetworkSetsListCmdLastEvaluatedKey string

var LoraNetworkSetsListCmdLimit int64

var LoraNetworkSetsListCmdTagName string

var LoraNetworkSetsListCmdTagValue string

var LoraNetworkSetsListCmdTagValueMatchMode string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraNetworkSetsListGatewaysCmdLastEvaluatedKey string

var LoraNetworkSetsListGatewaysCmdLimit int64

var LoraNetworkSetsListGatewaysCmdNsId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var LoraNetworkSetsRevokePermissionCmdBody string

var LoraNetworkSetsRevokePermissionCmdNsId string

var LoraNetworkSetsRevokePermissionCmdOperatorId string

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/operators/{operator_id}/auth_keys:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/auth_keys:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/operators/{operator_id}/auth_keys:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/auth_keys:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRCLI("cli.operator.summary"),
	Long:  TRCLI(`cli.operator.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorEnableMfaCmdOperatorId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/operators/{operator_id}:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorGetCmdOperatorId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorGetMfaStatusCmdOperatorId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/operators/email_change_token/issue:post:summary"),
	Long:  TRAPI(`/operators/email_change_token/issue:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

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

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorIssueMfaRevokeTokenCmdBody string

var OperatorIssueMfaRevokeTokenCmdEmail string

var OperatorIssueMfaRevokeTokenCmdPassword string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

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

		if result == "" {
			return nil
		}

		return prettyPrintStringAsJSON(result)
	},
}

var OperatorRevokeMfaCmdOperatorId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

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

		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: TRAPI("/operators/verify:post:summary"),
	Long:  TRAPI(`/operators/verify:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		param, err := collectOperatorVerifyCmdParams(ac)
		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: TRAPI("/operators/email_change_token/verify:post:summary"),
	Long:  TRAPI(`/operators/email_change_token/verify:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorVerifyEmailChangeTokenCmdParams(ac)
		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 OperatorVerifyMfaOtpCmd = &cobra.Command{
	Use:   "verify-mfa-otp",
	Short: TRAPI("/operators/{operator_id}/mfa/verify:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/mfa/verify:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOperatorVerifyMfaOtpCmdParams(ac)
		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 OperatorVerifyMfaOtpCmdBody string

var OperatorVerifyMfaOtpCmdMfaOTPCode string

var OperatorVerifyMfaOtpCmdOperatorId string

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

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

		param, err := collectOperatorVerifyMfaRevokeTokenCmdParams(ac)
		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 OperatorVerifyMfaRevokeTokenCmdBackupCode string

var OperatorVerifyMfaRevokeTokenCmdBody string

var OperatorVerifyMfaRevokeTokenCmdEmail string

var OperatorVerifyMfaRevokeTokenCmdPassword string

var OperatorVerifyMfaRevokeTokenCmdToken string

var OrdersCancelCmd = &cobra.Command{
	Use:   "cancel",
	Short: TRAPI("/orders/{order_id}/cancel:put:summary"),
	Long:  TRAPI(`/orders/{order_id}/cancel: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(ac)
		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: TRCLI("cli.orders.summary"),
	Long:  TRCLI(`cli.orders.description`),
}

var OrdersConfirmCmd = &cobra.Command{
	Use:   "confirm",
	Short: TRAPI("/orders/{order_id}/confirm:put:summary"),
	Long:  TRAPI(`/orders/{order_id}/confirm: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(ac)
		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: TRAPI("/orders:post:summary"),
	Long:  TRAPI(`/orders: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(ac)
		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: TRAPI("/orders/{order_id}:get:summary"),
	Long:  TRAPI(`/orders/{order_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOrdersGetCmdParams(ac)
		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: TRAPI("/orders:get:summary"),
	Long:  TRAPI(`/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(ac)
		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: TRAPI("/orders/{order_id}/subscribers:get:summary"),
	Long:  TRAPI(`/orders/{order_id}/subscribers:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOrdersListSubscribersCmdParams(ac)
		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: TRAPI("/orders/{order_id}/subscribers/register:post:summary"),
	Long:  TRAPI(`/orders/{order_id}/subscribers/register:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectOrdersRegisterSubscribersCmdParams(ac)
		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: TRCLI("cli.payer-information.summary"),
	Long:  TRCLI(`cli.payer-information.description`),
}

var PayerInformationGetCmd = &cobra.Command{
	Use:   "get",
	Short: TRAPI("/payment_statements/payer_information:get:summary"),
	Long:  TRAPI(`/payment_statements/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(ac)
		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: TRAPI("/payment_statements/payer_information:post:summary"),
	Long:  TRAPI(`/payment_statements/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(ac)
		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: TRCLI("cli.payment-history.summary"),
	Long:  TRCLI(`cli.payment-history.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectPaymentHistoryGetCmdParams(ac)
		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: TRCLI("cli.payment-methods.summary"),
	Long:  TRCLI(`cli.payment-methods.description`),
}

var PaymentMethodsGetCurrentCmd = &cobra.Command{
	Use:   "get-current",
	Short: TRAPI("/payment_methods/current:get:summary"),
	Long:  TRAPI(`/payment_methods/current: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(ac)
		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: TRAPI("/payment_methods/current/activate:post:summary"),
	Long:  TRAPI(`/payment_methods/current/activate: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(ac)
		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: TRCLI("cli.payment-methods.webpay.summary"),
	Long:  TRCLI(`cli.payment-methods.webpay.description`),
}

var PaymentMethodsWebpayRegisterCmd = &cobra.Command{
	Use:   "register",
	Short: TRAPI("/payment_methods/webpay:post:summary"),
	Long:  TRAPI(`/payment_methods/webpay: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(ac)
		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: TRCLI("cli.payment-statements.summary"),
	Long:  TRCLI(`cli.payment-statements.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectPaymentStatementsExportCmdParams(ac)
		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: TRAPI("/payment_statements:get:summary"),
	Long:  TRAPI(`/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(ac)
		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: TRCLI("cli.products.summary"),
	Long:  TRCLI(`cli.products.description`),
}

var ProductsListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/products:get:summary"),
	Long:  TRAPI(`/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(ac)
		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 QueryCmd = &cobra.Command{
	Use:   "query",
	Short: TRCLI("cli.query.summary"),
	Long:  TRCLI(`cli.query.description`),
}

var QuerySubscribersCmd = &cobra.Command{
	Use:   "subscribers",
	Short: TRAPI("/query/subscribers:get:summary"),
	Long:  TRAPI(`/query/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 := collectQuerySubscribersCmdParams(ac)
		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 QuerySubscribersCmdGroup []string

var QuerySubscribersCmdIccid []string

var QuerySubscribersCmdImsi []string

var QuerySubscribersCmdLastEvaluatedKey string

var QuerySubscribersCmdLimit int64

var QuerySubscribersCmdMsisdn []string

var QuerySubscribersCmdName []string

var QuerySubscribersCmdSearchType string

var QuerySubscribersCmdSerialNumber []string

var QuerySubscribersCmdTag []string

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectRolesCreateCmdParams(ac)
		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: TRAPI("/operators/{operator_id}/roles/{role_id}:delete:summary"),
	Long:  TRAPI(`/operators/{operator_id}/roles/{role_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectRolesDeleteCmdParams(ac)
		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: TRAPI("/operators/{operator_id}/roles/{role_id}:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/roles/{role_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectRolesGetCmdParams(ac)
		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: TRAPI("/operators/{operator_id}/roles:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/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(ac)
		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: TRAPI("/operators/{operator_id}/roles/{role_id}/users:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/roles/{role_id}/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(ac)
		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: TRAPI("/operators/{operator_id}/roles/{role_id}:put:summary"),
	Long:  TRAPI(`/operators/{operator_id}/roles/{role_id}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectRolesUpdateCmdParams(ac)
		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: TRCLI("cli.shipping-addresses.summary"),
	Long:  TRCLI(`cli.shipping-addresses.description`),
}

var ShippingAddressesCreateCmd = &cobra.Command{
	Use:   "create",
	Short: TRAPI("/operators/{operator_id}/shipping_addresses:post:summary"),
	Long:  TRAPI(`/operators/{operator_id}/shipping_addresses: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(ac)
		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: TRAPI("/operators/{operator_id}/shipping_addresses/{shipping_address_id}:delete:summary"),
	Long:  TRAPI(`/operators/{operator_id}/shipping_addresses/{shipping_address_id}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectShippingAddressesDeleteCmdParams(ac)
		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: TRAPI("/operators/{operator_id}/shipping_addresses/{shipping_address_id}:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/shipping_addresses/{shipping_address_id}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectShippingAddressesGetCmdParams(ac)
		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: TRAPI("/operators/{operator_id}/shipping_addresses:get:summary"),
	Long:  TRAPI(`/operators/{operator_id}/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(ac)
		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: TRAPI("/operators/{operator_id}/shipping_addresses/{shipping_address_id}:put:summary"),
	Long:  TRAPI(`/operators/{operator_id}/shipping_addresses/{shipping_address_id}:put:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectShippingAddressesUpdateCmdParams(ac)
		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 SigfoxDevicesCmd = &cobra.Command{
	Use:   "sigfox-devices",
	Short: TRCLI("cli.sigfox-devices.summary"),
	Long:  TRCLI(`cli.sigfox-devices.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesDeleteTagCmdParams(ac)
		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 SigfoxDevicesDeleteTagCmdDeviceId string

var SigfoxDevicesDeleteTagCmdTagName string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesDisableTerminationCmdParams(ac)
		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 SigfoxDevicesDisableTerminationCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesEnableTerminationCmdParams(ac)
		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 SigfoxDevicesEnableTerminationCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesGetCmdParams(ac)
		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 SigfoxDevicesGetCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesGetDataCmdParams(ac)
		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 SigfoxDevicesGetDataCmdDeviceId string

var SigfoxDevicesGetDataCmdFrom int64

var SigfoxDevicesGetDataCmdLastEvaluatedKey string

var SigfoxDevicesGetDataCmdLimit int64

var SigfoxDevicesGetDataCmdSort string

var SigfoxDevicesGetDataCmdTo int64

var SigfoxDevicesListCmd = &cobra.Command{
	Use:   "list",
	Short: TRAPI("/sigfox_devices:get:summary"),
	Long:  TRAPI(`/sigfox_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 := collectSigfoxDevicesListCmdParams(ac)
		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 SigfoxDevicesListCmdLastEvaluatedKey string

var SigfoxDevicesListCmdLimit int64

var SigfoxDevicesListCmdTagName string

var SigfoxDevicesListCmdTagValue string

var SigfoxDevicesListCmdTagValueMatchMode string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesPutTagsCmdParams(ac)
		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 SigfoxDevicesPutTagsCmdBody string

var SigfoxDevicesPutTagsCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesRegisterCmdParams(ac)
		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 SigfoxDevicesRegisterCmdBody string

var SigfoxDevicesRegisterCmdDeviceId string

var SigfoxDevicesRegisterCmdRegistrationSecret string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesSendDataCmdParams(ac)
		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 SigfoxDevicesSendDataCmdBody string

var SigfoxDevicesSendDataCmdData string

var SigfoxDevicesSendDataCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesSetGroupCmdParams(ac)
		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 SigfoxDevicesSetGroupCmdBody string

var SigfoxDevicesSetGroupCmdCreatedTime int64

var SigfoxDevicesSetGroupCmdDeviceId string

var SigfoxDevicesSetGroupCmdGroupId string

var SigfoxDevicesSetGroupCmdLastModifiedTime int64

var SigfoxDevicesSetGroupCmdOperatorId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesTerminateCmdParams(ac)
		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 SigfoxDevicesTerminateCmdDeviceId string

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSigfoxDevicesUnsetGroupCmdParams(ac)
		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 SigfoxDevicesUnsetGroupCmdDeviceId string

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

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectStatsAirExportCmdParams(ac)
		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: TRAPI("/stats/air/subscribers/{imsi}:get:summary"),
	Long:  TRAPI(`/stats/air/subscribers/{imsi}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectStatsAirGetCmdParams(ac)
		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: TRCLI("cli.stats.beam.summary"),
	Long:  TRCLI(`cli.stats.beam.description`),
}

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

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectStatsBeamExportCmdParams(ac)
		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: TRAPI("/stats/beam/subscribers/{imsi}:get:summary"),
	Long:  TRAPI(`/stats/beam/subscribers/{imsi}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectStatsBeamGetCmdParams(ac)
		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: TRCLI("cli.stats.summary"),
	Long:  TRCLI(`cli.stats.description`),
}

var SubscribersActivateCmd = &cobra.Command{
	Use:   "activate",
	Short: TRAPI("/subscribers/{imsi}/activate:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/activate: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(ac)
		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: TRCLI("cli.subscribers.summary"),
	Long:  TRCLI(`cli.subscribers.description`),
}

var SubscribersDeactivateCmd = &cobra.Command{
	Use:   "deactivate",
	Short: TRAPI("/subscribers/{imsi}/deactivate:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/deactivate: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(ac)
		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: TRAPI("/subscribers/{imsi}/delete_session:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/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(ac)
		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: TRAPI("/subscribers/{imsi}/tags/{tag_name}:delete:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/tags/{tag_name}:delete:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSubscribersDeleteTagCmdParams(ac)
		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: TRAPI("/subscribers/transfer_token/{token}:delete:summary"),
	Long:  TRAPI(`/subscribers/transfer_token/{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(ac)
		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: TRAPI("/subscribers/{imsi}/disable_termination:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/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(ac)
		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: TRAPI("/subscribers/{imsi}/enable_termination:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/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(ac)
		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: TRAPI("/subscribers/{imsi}:get:summary"),
	Long:  TRAPI(`/subscribers/{imsi}:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSubscribersGetCmdParams(ac)
		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: TRAPI("/subscribers/{imsi}/data:get:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/data:get:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSubscribersGetDataCmdParams(ac)
		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: TRAPI("/subscribers/transfer_token/issue:post:summary"),
	Long:  TRAPI(`/subscribers/transfer_token/issue:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSubscribersIssueTransferTokenCmdParams(ac)
		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: TRAPI("/subscribers:get:summary"),
	Long:  TRAPI(`/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(ac)
		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: TRAPI("/subscribers/{imsi}/tags:put:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/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(ac)
		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: TRAPI("/subscribers/{imsi}/register:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/register:post:description`),
	RunE: func(cmd *cobra.Command, args []string) error {
		opt := &apiClientOptions{
			BasePath: "/v1",
			Language: getSelectedLanguage(),
		}

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

		err := authHelper(ac, cmd, args)
		if err != nil {
			cmd.SilenceUsage = true
			return err
		}

		param, err := collectSubscribersRegisterCmdParams(ac)
		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 SubscribersReportLocalInfoCmd = &cobra.Command{
	Use:   "report-local-info",
	Short: TRAPI("/subscribers/{imsi}/report_local_info:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/report_local_info: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 := collectSubscribersReportLocalInfoCmdParams(ac)
		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 SubscribersReportLocalInfoCmdImsi string

var SubscribersSendSmsCmd = &cobra.Command{
	Use:   "send-sms",
	Short: TRAPI("/subscribers/{imsi}/send_sms:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/send_sms: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 := collectSubscribersSendSmsCmdParams(ac)
		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 SubscribersSendSmsCmdBody string

var SubscribersSendSmsCmdEncodingType int64

var SubscribersSendSmsCmdImsi string

var SubscribersSendSmsCmdPayload string

var SubscribersSessionEventsCmd = &cobra.Command{
	Use:   "session-events",
	Short: TRAPI("/subscribers/{imsi}/events/sessions:get:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/events/sessions: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(ac)
		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: TRAPI("/subscribers/{imsi}/set_expiry_time:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/set_expiry_time: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(ac)
		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: TRAPI("/subscribers/{imsi}/set_group:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/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(ac)
		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: TRAPI("/subscribers/{imsi}/set_imei_lock:post:summary"),
	Long:  TRAPI(`/subscribers/{imsi}/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(ac)
		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)
	},
}